more docs

5 files changed, 125 insertions, 5 deletions

diff --git a/README.html b/README.html
index fe1fd75..e34ab71 100644
--- a/README.html
+++ b/README.html
@@ -28,4 +28,67 @@ it is nearly as fast in theory.</p>
 
 <p><code>tests</code> has some test programs written in <code>toc</code>.</p>
 
-<p>To compile the compiler on a Unix-y system, use</p>
+<p>To compile the compiler on a Unix-y system, just run <code>build.sh</code>. You can supply a compiler by running <code>CC=tcc build.sh</code>, or built it in release mode with <code>./build.sh release</code> (which will help speed up compiling large programs). </p>
+
+<p>On other systems, you can just compile main.c with a C compiler. toc uses several C99 and a couple of C11 features, so it might not work on all compilers. But it does compile on quite a few, including <code>clang</code>, <code>gcc</code>, and <code>tcc</code>. It can also be compiled as if it were C++, but it does break the standard in a few places*. So, MSVC can also compile it. The <em>outputted</em> code should be C99-compliant.</p>
+
+<hr />
+
+<h3><code>toc</code> Source Code</h3>
+
+<p><code>toc</code> is written in C, for speed and portability. It has no dependencies, other than the C runtime library.</p>
+
+<h4>Build system</h4>
+
+<p><code>toc</code> is set up as a unity build, meaning that there is only one translation unit. So, <code>main.c</code> <code>#include</code>s <code>toc.c</code>, which <code>#include</code>s all of <code>toc</code>'s files. This improves (from scratch) compilation speeds, since you don't have to include headers a bunch of times for each translation unit. This is more of a problem in C++, where, for example, doing <code>#include &lt;map&gt;</code> ends up turning into 25,000 lines after preprocessing. All of toc's source code, which includes most of the C standard library, at the time of this writing (Dec 2019) is only 22,000 lines after preprocessing; imagine including all of that once for each translation unit which includes <code>map</code>. It also obviates the need for fancy build systems like CMake.</p>
+
+<h4>New features</h4>
+
+<p>Here are all the C99 features which <code>toc</code> depends on (I might have forgotten some...):</p>
+
+<ul>
+<li>Declare anywhere</li>
+<li><code>stdint.h</code></li>
+<li>Non-constant struct literal initializers (e.g. <code>int x[2] = {y, z};</code>)</li>
+<li>Variadic macros and <code>__VA_ARGS__</code></li>
+<li>Flexible array members</li>
+</ul>
+
+<p>The last three of those could all be removed fairly easily.</p>
+
+<p>And here are all of its C11 features:</p>
+
+<ul>
+<li>Anonymous structures/unions</li>
+<li><code>max_align_t</code> and <code>alignof</code> - It can still compile without these but it won't technically be standard-compliant</li>
+</ul>
+
+<h4>More</h4>
+
+<p>See <code>main.c</code> for a bit more information.</p>
+
+<hr />
+
+<p>* for those curious, it has to do with <code>goto</code>. In C, this program:</p>
+
+<pre><code>
+int main() {  
+    goto label;  
+    int x = 5;  
+    label:  
+    return 0;  
+}
+</code></pre>
+
+<p>Is completely fine. <code>x</code> will hold an unspecified value after the jump (but it isn't used so it doesn't really matter). Apparently, in C++, this is an ill-formed program. This is a bit ridiculous since</p>
+
+<pre><code>
+int main() {  
+    goto label;  
+    int x; x = 5;  
+    label:  
+    return 0;  
+}
+</code></pre>
+
+<p>is fine. So that's an interesting little "fun fact": <code>int x = 5;</code> isn't always the same as <code>int x; x = 5;</code> in C++.</p>
diff --git a/README.md b/README.md
index 4cbe8a7..9720134 100644
--- a/README.md
+++ b/README.md
@@ -23,9 +23,64 @@ x : int; x = 5; // Declare x as an integer, then set it to 5.
 
 `toc` is statically typed and has many of C's features, but
 it is nearly as fast in theory.
-
+ 
 See `docs` for more information (in progress).
 
 `tests` has some test programs written in `toc`.
 
-To compile the compiler on a Unix-y system, use
+To compile the compiler on a Unix-y system, just run `build.sh`. You can supply a compiler by running `CC=tcc build.sh`, or built it in release mode with `./build.sh release` (which will help speed up compiling large programs). 
+
+On other systems, you can just compile main.c with a C compiler. toc uses several C99 and a couple of C11 features, so it might not work on all compilers. But it does compile on quite a few, including `clang`, `gcc`, and `tcc`. It can also be compiled as if it were C++, but it does break the standard in a few places\*. So, MSVC can also compile it. The *outputted* code should be C99-compliant.
+
+---
+
+### `toc` Source Code
+
+`toc` is written in C, for speed and portability. It has no dependencies, other than the C runtime library.
+
+#### Build system
+`toc` is set up as a unity build, meaning that there is only one translation unit. So, `main.c` `#include`s `toc.c`, which `#include`s all of `toc`'s files. This improves (from scratch) compilation speeds, since you don't have to include headers a bunch of times for each translation unit. This is more of a problem in C++, where, for example, doing `#include <map>` ends up turning into 25,000 lines after preprocessing. All of toc's source code, which includes most of the C standard library, at the time of this writing (Dec 2019) is only 22,000 lines after preprocessing; imagine including all of that once for each translation unit which includes `map`. It also obviates the need for fancy build systems like CMake.
+
+#### New features
+
+Here are all the C99 features which `toc` depends on (I might have forgotten some...):
+
+- Declare anywhere
+- `stdint.h`
+- Non-constant struct literal initializers (e.g. `int x[2] = {y, z};`)
+- Variadic macros and `__VA_ARGS__`
+- Flexible array members
+
+The last three of those could all be removed fairly easily.
+
+And here are all of its C11 features:
+
+- Anonymous structures/unions
+- `max_align_t` and `alignof` - It can still compile without these but it won't technically be standard-compliant
+
+#### More
+
+See `main.c` for a bit more information.
+
+---
+
+
+\* for those curious, it has to do with `goto`. In C, this program:
+<pre><code>
+int main() {  
+	goto label;  
+	int x = 5;  
+	label:  
+	return 0;  
+}
+</code></pre>
+Is completely fine. `x` will hold an unspecified value after the jump (but it isn't used so it doesn't really matter). Apparently, in C++, this is an ill-formed program. This is a bit ridiculous since
+<pre><code>
+int main() {  
+	goto label;  
+	int x; x = 5;  
+	label:  
+	return 0;  
+}
+</code></pre>
+is fine. So that's an interesting little "fun fact": `int x = 5;` isn't always the same as `int x; x = 5;` in C++.
diff --git a/docs.sh b/docs.sh
index 81cde33..87e4112 100755
--- a/docs.sh
+++ b/docs.sh
@@ -1,4 +1,4 @@
-#!/bin/bash
+#!/bin/sh
 markdown README.md > README.html
 for x in docs/*.md; do
 	echo $x
diff --git a/main.c b/main.c
index da2303e..592dc7d 100644
--- a/main.c
+++ b/main.c
@@ -31,6 +31,8 @@ allow omission of trailing ; in foo ::= fn() {}?
 #ifdef __cplusplus
 #define new new_
 #define this this_
+#elif __STDC_VERSION__ < 199901
+#define inline
 #endif
 
 #include "toc.c"
diff --git a/parse.c b/parse.c
index d80afd1..efd78d4 100644
--- a/parse.c
+++ b/parse.c
@@ -1931,7 +1931,7 @@ static bool parse_file(Parser *p, ParsedFile *f) {
 	return ret;
 }
 
-#define PARSE_PRINT_LOCATION(l) //fprintf(out, "[l%lu]", (unsigned long)(l).line);
+#define PARSE_PRINT_LOCATION(l) /* fprintf(out, "[l%lu]", (unsigned long)(l).line); */
 
 /* in theory, this shouldn't be global, but these functions are mostly for debugging anyways */
 static bool parse_printing_after_types;