Which will probably be never.
I mean, all cmake does is run some commands for you. You not understanding cmake errors (mostly) means you don’t understand the errors given to you by the C/C++ compiler.
Partly, yes. But I also think their documentation is a bit hard do read. Maybe this will get better with time.
I use rust btw.
Maybe this will get better with time.
Yes, just give it a few more decades.
CMake can also emit its own errors during the configure step though, particularly if you have complicated build logic and/or lots of external packages.
Grab a brush and put a little cmakeup.
Wrong class, you’ll need cbrush.
UNDEFINED SYMBOL AAHDYVBBDJFUE804746BBBB
Life is and will always be better writing your own Makefiles. It’s literally so easy. I do not get the distaste. Cmake is arcane magic. Bazel is practically written in runes. Makefile is a just a glorified build script, but where you don’t have to use a bunch of if statements to avoid building everything each time.
That works until you need to support Visual Studio or Xcode. Then you either maintain their stuff manually too, or you get CMake to generate all three. I don’t love it but it solves the problem it’s meant to solve. The issue is people using it when they don’t need to.
You can build with mingw64 built with msvc and use more or less the same Makefile. As for Xcode… well, there’s not really a good reason to support Mac. On principle I wouldn’t even try
Manual makefiles don’t scale though and you end up needing some other bootstrap framework pretty quick.
How the heck does a Makefile not scale??? That’s all it does!
this is fine until you need autotools which is worse than cmake
Thanks for the laugh.
That was also my experience, but it ended when I stopped using
cmake.I’m not mad at anyone for using
cmake, but I consider myself blessed on each day that I don’t have to collaborate with them (oncmake).Which is weird, because someone will have to pry a
Makefilefrom my cold dead hands, someday.Professional CMake: A Practical Guide by Craig Scott is an excellent guide to modern cmake usage. Well worth the $30 if you need to build, maintain, or modify a CMake project.
Thanks a lot!
And an update has just been released today!
There are cmake debuggers where you can walk through exactly what it’s doing line by line
Do you have a good one which you can recommend?
cmake debugger
I use this one in vscodium https://open-vsx.org/vscode/item?itemName=ms-vscode.cmake-tools
Thanks!
Who debugs the builds of the build debugger?
I forgot to assign a variable, now it crashes %5 of the time. It’s wild how c doesn’t default variables to null or something.
C does exactly what you tell it, no more. Why waste cycles setting a variable to a zero state when a correct program will set it to whatever initial state it expects? It is not user friendly, but it is performant.
Except that this is wrong. C is free to do all kinds of things you didn’t ask it to, and will often initialize your variables without you writing it.
Machine code would be a better example of what he’s talking about imo. Not an expert or anything of course.
Odds are that your computer doesn’t export any language where it will do exactly as you say (amd64 machine code certainly won’t execute exactly as written). And how much difference it makes varies from one language to another.
But the specific example from the OP, of uninitialized variables, is one of those cases where the C spec famously goes completely out of line and says your code can do whatever, run with a random value, fail, initialize it, format your hard drive, make a transaction on your bank account… whatever.
It wouldn’t be that much processing compared to the rest of the app. It would lot more efficient than running an effectively infinite loop or arithmetic on an arbitrarily large number as a result of an unsigned variables.
sudo make me a cmake
I never finished reading my CMake book that weights about two kilos. It’s now outdated, except for the core concepts.
That’s like one thing ML can actually help with XD cute cat
Imo just use something else. If your build system is really simple just write the Makefiles yourself. If the build system tho needs to be really complex I would use something like meson or scons (Having worked on some gigantic fully GNU make build systems it can get pretty out of hand).
This is all a personal preference thing but cmake in my experience is really non intuitive and a pain to debug. I know it works for a lot of people but I definitely prefer particularly like scons since its python I have a bit easier time understanding what’s happening.
If you really need to use cmake, use a debugger like another user commented. There’s also a GNU make debugger in case you need to debug makefiles
