pp: Allow macro expansion inside #if conditions
ast: Let astDump() show attributes
Fix #include guard detection to check whether #if/#endif belong together
Remove hRemoveIncludeGuard(), can use #if block evaluation instead
pp: Expand macros while walking through code, not globally

- let ppExpand() walk through code top-down, with a stack to hold precious
  #defines from the current #if blocks. This allows it to forget #defines
  when leaving #if blocks. This way it can still expand macro calls only in
  the #if/#else block where thee #define was found (relying on the
  ppIntegrateTrailCodeIntoIfElseBlocks() transformation being done first)

- let ppMacro*() add macros to that stack, like pre-defined macros, instead
  of expanding globally. This is the only way to prevent false expansions,
  like if a macro parameter has the same name as a macro, but it still
  shouldn't be expanded as that macro.

- Added support for #undef
pp: Show errors for misusage of ppAddSym/ppExpandSym
pp: Fix memory leak in macro expansion
pp: Don't expand macros in "defined id" expressions
Treat ptrdiff_t as INTEGER
pp: Eval/expand unconditionally only, no more trail code duplication

Instead of turning this:
	#ifdef foo
		#define f f1
	#else
		#define f f2
	#endif
	void f(void);
into this:
	#ifdef foo
		#define f f1
		void f(void);
	#else
		#define f f2
		void f(void);
	#endif
to handle expansion of conditionally defined macros, it seems better to
simply expect any #ifs to be solved out by presets to remove any ambiguity,
and parse the same header multiple times, each with different pre-#defines
as needed to extract the wanted declarations.

The problem with the trail-code-duplication is that it has to be done for
every single #if containing a precious #define or #undef, before #if
evaluation can be done, and that seriously blows up the tk buffer size
even for medium sized headers if they use lots of #ifs. Most of the
duplicate code will be solved out by #if evaluation but nevertheless it
slows down the preprocessing step a lot.

Normally a binding only really needs to be parsed on "Linux" or "Win32"
modes, i.e. a lot of uninteresting cases can be ignored immediately.

Of course fbfrog should still support leaving in unsolvable #if blocks,
whose conditions couldn't be evaluated. If a precious #define or #undef is
found in an unsolvable #if block, fbfrog needs to oops() because the preset
didn't do its job of specifying the proper symbols needed to solve all
important #if blocks, and now fbfrog can't know whether that precious
#define or #undef will be reached or not. Checking for this is what makes
it safe to do the macro expansion this way.

Multiple completely separate parsing passes is exactly what will be done
to handle multiple library versions, and the same kind of AST merging is
needed afterwards, so unlike the trail-code-duplication, no extra merging
code is needed.

- Duplicate #defines will now be checked for equality, oops() in case the
  2nd #define is incompatible to the 1st (gcc would warn about
  incompatible redefinition)
pp: Abort ppEval() instead of oops()ing, and then finish emitting

to allow the user find out where ppEval() failed.
Remove AST exporting/importing; should import generated FB code instead
pp: Solve out escaped EOLs when recording macro bodies