Cleanup: split macro argument parser into a small functions.
Untabify.
Cleanup: rename "tostring" functions.

Short names are generally good but they are too short.
Reanme a2s -> node2s, c2s -> ty2s, and t2s -> tok2s.

I tried to use C11 _Generic to define a generic "tostring" macro
like this.

#define S(x) _Generic((x), Node*:node2s, Type*:ty2s, Token*:tok2s)(x)

However this didn't compile with GCC 4.8.2 (Clang 3.4 did).
It may also be confusing to those who are not familiar with the new
C11 feature. So I decided to not use that.
Rename sharp -> hash.

C11 uses both sharp and hash to refer this symbol.
This is a matter of taste. I choose hash because that looks more common.
Define Set type to use for hideset.

We used to use a Map to represent a hideset. Using Map felt
a bit awkward because of the nature of the Map. We needed
to make a copy of a Map conservatively so that the other token
sharing the same hideset wouldn't clobber the Map contents.

Only a few percent of total tokens are usually become a
subject of macro expansion. Almost all tokens don't need
hidesets at all. Allocating a map to each token looked
a bit waste.

So I decided to defined a new type. The new type is very simple.
It may look too simple, but I believe it's good enough for us.
Cleanup: use memcpy instead of for loop.
Simplify.
Add a comment.
Fix a minor preprocessor bug.

C11 6.10.3p10 says "within the sequence of preprocessing
tokens making up an invocation of a function-like macro,
new-line is considered a normal white-space character."

GCC and Clang seem to convert newline characters in
func-like macro arguments to space characters.
This patch makes 8cc compatible with the major compilers.
Add iso646.h.

Nobody is really using this, but this is still
a part of the standard.
Cleanup.

IIRC the reason why I wrote "!(a == b)" is because
there was no != operator in 8cc at that moment.
I don't remember why I didn't use early returns.
Anyways now there's no reason to write this way.
Initial commit for the new backend.
Compile a dumb simple program. No register allocation yet.

It's now able to compile

  int main() { int x = 2; return x + 5; }
Implement very simple register allocator.

It reserves stack space for all intermediate results.
It always spills an intermediate result when we run out of registers
even if the result will never be needed again. (In order to elminate
such stores, we need liveness analysis.)

Currently it assumes all variables are of type int.
Support assignment, array and pointer arithmetics.