1. Introduction

2. Overview Of The Course

3. Installation & Setup

4. Preparing our Project

5. What is Lexical Analysis

6. Creating Our Token Structures

7. Preparing Our Lexer

8. Creating a number token

9. Creating a string token

10. Creating a operator token

11. Creating a symbol token

12. Creating a identifier token

13. Creating a keyword token

14. Creating a new line token

15. Creating a comment token

16. Handling quotes in the Lexer

17. Implementing Hexadecimal Numbers

18. Implementing Binary Numbers

19. Dealing with the parentheses buffer

20. Creating tokens outside of the input file

21. Creating number types

22. Finalizing the lexer

23. What is parsing

24. Creating our parser structures

25. Writing our parser template

26. Creating our node file

27. Creating our first node

28. Creating an expression node

29. Dealing with precedence in expression - Part 1

30. Dealing with precedence in expression - Part 2

31. Dealing with precedence in expression - Part 3

32. Creating an identifier node

33. Implementing datatypes and keywords - Part 1

34. Implementing datatypes and keywords - Part 2

35. Implementing datatypes and keywords - Part 3

36. Implementing datatypes and keywords - Part 4

37. Understanding scopes

38. Implementing the scopes

39. Understanding Symbol Resolution

40. Implementing The Symbol Resolver

41. Implementing datatypes and keywords - Part 5

42. Implementing Variables - Part 1

43. Implementing Variables - Part 2

44. Implementing Variables - Part 3

45. Understanding Array Declarations

46. Implementing the calculation of array sizes

47. Implementing Structures - Part 1

48. Implementing Structures - Part 2

49. Implementing Body's - Part 1

50. What is padding and alignment

51. Implementing datatype size functions

52. Implementing variable size functions

53. Implementing Alignment and Padding Functions

54. Implementing Body's - Part 2

55. Implementing Body's - Part 3

56. Scope offsets explained

57. Implementing parser scope entities and functionalities

58. Implementing the variable node scope offset - Part 1

59. Implementing the variable node scope offset - Part 2

60. Implementing the variable node scope offset - Part 3

61. Pushing variables to the scope

62. Implementing Body's - Part 4

63. Implementing Body's - Part 5

64. Implementing Structures - Part 3

65. Implementing Structures - Part 4

66. Initializing our symbol resolver

67. Testing our structure functionality

68. Error checking our structures

69. Project cleanup

70. Understanding Functions

71. Implementing The Function Structures

72. Parsing functions

73. Parsing functions arguments

74. Dealing with upward stacks

75. Changing the parsing of identifiers

76. Res = 0 is missing

77. Implementing expression parentheses

78. Implementing IF statement

79. Implementing Else And Else If

80. Fixing some compiler warnings

81. Implementing the return statement

82. Implementing for loops

83. Implementing while loops

84. Implementing Do While Loops

85. Implementing switch statements

86. Implementing continue and break

87. Implementing labels

88. Implementing goto

89. Implementing switch cases

90. Implementing tenaries

91. Implementing commas

92. Implementing array brackets

93. Implementing casts

94. Case indexes or our register case function

95. Understanding Fixups

96. Creating our fixup core functionality

97. Integrating our fixup functionality into the parser

98. Parsing forward declarations

99. Parsing unions

100. Adjusting the function stack size

101. Additional recording for nodes

102. Module 1 Summary

103. Module 2 Information

104. The Code generator

105. Building the fundementals

106. Beginning the iteration of the AST

107. Generating global variables

108. Understanding the label systems

109. Building the label system

110. Dealing with strings in the code generator

111. Building our string registration system

112. Implementing numerical values for global variables

113. Implementing string values for global variables

114. Fixing issue parsing strings

115. Stackframes

116. Building our stack frame functionality

117. The resolver explained

118. Creating the resolver - Part 1

119. Creating the resolver - Part 2

120. Creating the resolver - Part 3

121. How array offsets are calculated

122. Creating the resolver - Part 4

123. Creating the resolver - Part 5

124. Calculating structure and union offsets

125. Implementing the struct_offset function

126. Creating the resolver - Part 6

127. Creating the resolver - Part 7

128. Creating the resolver - Part 8

129. Creating the resolver - Part 9

130. Creating the resolver - Part 10

131. Implementing unaries

132. Creating the resolver - Part 11

133. Creating the resolver - Part 12

134. Creating the resolver - Part 13

135. Creating the resolver - Part 14

136. Creating the resolver - Part 15

137. Creating the resolver default handler

138. Starting to implement function code generation

139. Implementing the foundation of scope variables

140. Fixing the parser_scope_offset_for_stack function

141. Assigning Variables

142. Code generator response system

143. Implementing the code generator response system and expressions

144. Running our first program

145. Modifying our parser_datatype_init_type_and_size function

146. Generating identifier variable access

147. Handling pointer values in expressions

148. Implementing logical operators

149. Implementing function calls

150. Generating structures

151. Generating structures - Part 2

152. Generating the get address operator

153. Useful resources

154. Finishing the codegen_resolve_node_for_value function

155. Finishing unaries

156. Generating unsupported entities

157. Generating statement return

158. Generating if statements

159. Generating while loops

160. Generating do while loops

161. Generating for loops

162. Generating break statements

163. Generating continue statements

164. Fixing bug in for statements

165. Creating switch statements

166. Creating switch statements Part 2

167. Creating switch statements Part 3

168. Generating goto statements

169. Creating labels

170. Creating strings and calling printf

171. Generating expression parenthesis

172. Creating tenary nodes

173. Generating casts

174. Generating array access

175. Generating array access - Part 2

176. Fixing a bug with indirection assignments

177. Generating unions

178. Generating array variables in the global scope

179. Finishing the codegen_generate_global_variable function

180. Generating variable lists

181. Escaping characters

182. Finishing our operators

183. Implementing the ++ and -- operators

184. Fixing a couple bugs

185. Fixing a bug with the switch statements default case

187. The preprocessor brief introduction

188. What is the expressionable system

189. Creating our expressionable structures

190. Creating our expressionable system - Part 1

191. Creating our expressionable system - Part 2

192. Creating our expressionable system - Part 3

193. Creating our expressionable system - Part 4

194. Creating our expressionable system - Part 5

195. Creating our expressionable system - Part 6

196. The Preprocessor Internal And Mechanics

197. Creating the preprocessor structures

198. Beginning the preprocessor logic

199. Creating the preprocessor expressionable configuration

200. Creating the define macro

201. Creating macro arguments

202. Implementing undef

203. Implementing the macro warning

204. Implementing the macro error

205. Creating the ifdef macro

206. Creating the ifndef macro

207. Evaluating expressions in the preprocessor - Part 1

208. Implementing the if macro

209. Evaluating expressions in the preprocessor - Part 2

210. Evaluating the expressions in the preprocessor part 3

211. Evaluating the expressions in the preprocessor part 4

212. Understanding macro functions

213. Implementing macro functions - Part 1

214. Getting the value of definitions from within source code

215. Implementing macro functions part 2

216. Implementing macro functions part 3

217. Finishing the typedef directive - Part 1

218. Finishing the typedef directive - Part 2

219. Implementing macro strings - Part 1

220. Implementing macro strings - Part 2

221. Implementing preprocessor unary not

222. Fixing a mistake with logical not in the code generator

223. Implementing the parentheses node in the preprocessor

224. Implementing joined nodes in the preprocessor

225. Evaluating tenaries in the preprocessor

226. Processing concat directive in the preprocessor

227. Creating native definitions - Part 1

228. Creating native definitions - Part 2

229. Implementing includes - Part 1

230. Implementing includes - Part 2

231. Implementing includes - Part 3

232. Implementing sizeof

233. Fixing some issues with casting pointers

234. Implementing offsetof

235. Adding our source file as an included file

236. Implementing Native Functions - Part 1

237. Implementing Native Functions - Part 2

238. Implementing VALIST - Part 1

239. Implementing VALIST - Part 2

240. Finishing some important header files

241. Summary Module 3

242. What is semantic validation?

243. Building the foundations

244. Implementing validator scopes

245. Implementing validation of functions

246. Implementing validation of variables

247. Implementing the validation of statements

248. Implementing the validation of structures and unions

249. Continuing the validator