<\/div>You just shove your source code through the magical compile-o-matic and out pops a video game!\u00a0\u00a0<\/p>\n
The reality is that it’s not nearly so simple. In the world of C++, the “compiler” isn’t even a single program! The reality is closer to something like this:<\/p>\n
<\/div>This is still<\/b> a pretty big simplification, but this is enough for the discussion we’re having today. The process of taking source code and turning it into an executable program involves at least three different programs and there are a lot of ways for things to go wrong.<\/p>\nIDE<\/h3>\n
<\/div>In our modern jet-setting future, we have lovely programming environments called IDEIntegrated Development Environment.<\/span>s that handle all of your text-editing duties. For the vast majority of people programming on Windows, this means using Microsoft Visual Studio. I’m somewhat notorious for bashing Microsoft<\/a> for their many<\/a> many<\/a> egregious<\/a> shortcomings<\/a>. But while their operating system is a griefing engine<\/a> and their gaming software is an affront to sanity<\/a>, I’ll admit their programming tools are actually pretty dang good. It’s even free<\/a> these days. Good and<\/b> free? That’s pretty un-Microsoft of them.<\/p>\n Your IDE will recognize what programming language you’re using and can color the code accordingly. A good one will understand the code well enough to help you find definitions of things, set bookmarks, highlight undefined variablesIt’s basically a spell checker, but for code.<\/span>, search the code, and auto-complete things for you. It’s pretty great.<\/p>\n At some point you’re done typing code and you wrongly assume you’re ready to compile. You’ll hit a keyboard shortcut and your IDE will invoke…<\/p>\n Like I said at the start of this series, C++ is descended from C, and thus it inherited a lot of things that were necessary in 1972 but made no damn sense in the 1990s and are farcical today.<\/p>\n Back in the old days, memory was precious. You only had a few kilobytes to work with. There was no way the compiler could parse the dozens of files in your project in one go and hold all their information in memory. So instead the compiler was designed so that it could only compile one file at a time. It runs once on aircraft.c, and turns that file into binary data. Then it runs again on bullets.c, then cars.c, then guns.c, then helicopter.c, and so onI’m not sure why you’re trying to develop Arma<\/a> in 1972. Did you check the target hardware? I don’t think you have enough memory for all of this.<\/span>. Each file can only be considered in isolation.<\/p>\n This one-file-at-a-time approach remains today, and I don’t think you could change it without making huge disruptive changes to how the language works. The good news is that modern computers can invoke more than one instance of the compiler at a time. You can have a compiler working on bullets.c and another instance working on cars.c. The two instances can’t cooperate and they end up doing quite a bit of redundant work, but at least you don’t need to wait for bullets.c to finish before it starts on cars.c. <\/p>\n There are a lot of steps to reading in the text. Here are a few notable ones:<\/p>\n As the name suggests, this is something done before the text is processed. Probably the simplest and most common use of this is for defined symbols. Perhaps the programmer has a specific number that gets used a lot in code:<\/p>\n Then elsewhere in the code, you’ll have something like this:<\/p>\n Everywhere in the code where we need to deal with acceleration due to gravity, we can use the #defined symbol GRAVITY. Before attempting to compile your program, the preprocessor will go through and replace every instance of the word GRAVITY with the value 9.8. This has two advantages. One, another programmer might not be able to understand what 9.8 means, but if they see the word GRAVITY then they’ll get what the code is doing. Secondly, this allows you to change the value in a single location. If you later realize this game is supposed to take place on the moon, you can replace 9.8 with 1.625. You only need to change a single line of code, rather than manually tracking down all gravity-related code and changing all instances of 9.8 individually.<\/p>\n The other major thing the preprocessor does for us is it allows us to use different code for different builds of the game. Maybe we have a function called “Desync” that gets called in the event of some serious error.\u00a0In the code below, we have two different versions of that code:<\/p>\n Normally you can’t have two functions with the same name like thisYes, I know you can if they have different signatures, but I’m not going to stop and explain signatures right now.<\/span>. But the preprocessor looks at what version of the game you’re compiling. It keeps the Desync you want and ignores the other. <\/p>\n This is a simple example, but these options can get really complex and it might take you a minute to figure out which of the six different versionsMaybe this game is being developed for the PC, PlayStation, and Xbox, and each platform needs different behavior for the shipping version of the game vs. the pre-release builds for reviewers.<\/span> of DeSync() is actually active. In a modern setup, your IDE can usually highlight whichever version is active and leave the others greyed out. We didn’t have this back in the 90s, and I remember having confusing moments where I was trying to fix a bug and wondering why my fixes weren’t doing anything, only to discover later that I was editing the wrong version of DeSync()Or whatever the function was called. I’ve long since forgotten.<\/span>. Eventually I learned to double-check which version was really being compiled. I’d type some lazy garbage into the function like “dsklja;gf”, and hit compile. If the compiler didn’t complain, then I’d messed up and was working on a disabled bit of code.<\/p>\n This is actually two different steps, but we can treat them as one for the purposes of this discussion. The compiler has to read in the text and figure out what the programmer was trying to express. In C++, this job is apparently very difficult<\/a> for the people writing the compiler, but for the average game developer it’s as easy as slapping F7Or whatever the hotkey is in your IDE.<\/span>.\u00a0<\/p>\n If the code doesn’t make sense because of typos \/ stray characters \/ misspellings \/ missing characters then the compiler will issue an error. If you’re having a good day, then the error will be simple, understandable, and point you to the source of the problem. If you’re having a normal day, then the compiler will report the problem in a confusing \/ misleading wayActually, error messages are pretty good these days. They’re not particularly newbie-friendly, but then C itself isn’t particularly newbie friendly.<\/span>.\u00a0<\/p>\nThe Compiler<\/h3>\n
1. Preprocessor<\/h3>\n
#define GRAVITY 9.8<\/pre>\n
void SpaceMarine::Falling ()\r\n\r\n{\r\n\u00a0\u00a0\/\/Shouldn't this be multiplied by some sort of timescale? Do our physics run at 1FPS? -SY\u00a0\r\n\u00a0\u00a0fall_speed = fall_speed + GRAVITY;\r\n}<\/pre>\n#ifdef ALPHA\r\n\r\nvoid DeSync ()\r\n{\r\n \/\/This is the public alpha build of the game, so here we would have some code to pop up a dialog box.\r\n \/\/We could explain the desync situation and ask the user to provide additional details about what they were\u00a0\r\n \/\/doing before the error occurred. The game would send that back to the master server where it would be\r\n \/\/stored for later review by the developers.\r\n}\r\n\r\n#else\u00a0\r\n\r\nvoid DeSync ()\r\n{\r\n \/\/This is the release build of the game. Just issue a generic \"Lost connection to server\" message\r\n \/\/and dump the user back to the main menu.\r\n}\r\n\r\n#endif<\/pre>\n2. Lexical \/ Syntax Analysis<\/h3>\n
3. Object Code<\/h3>\n