Do not truncate the existing attribute list if a __declspec has no arguments.

Correct anchor underflow in case of error in parse_microsoft_extended_decl_modifier().

Improve error recovery in parse_compound_statement().

- Handle EOF generically with expect().
- Do not skip semantic checks, when breaking out of the parsing loop due to an error.

Remove pointless skip loop: intern_parse_statement() only returns a single statement.

Remove pointless test: If intern_parse_statement() returns a STATEMENT_ERROR, then the current token is an anchor.

Remove stale TODO.

Improve error recovery in parse_asm_statement() and do not return an error statement.

Improve error recovery in parse_do() and do not return an error statement.

Improve error recovery in parse_for() and do not return an error statement.

Plug an extension leak on parse error in parse_for().

Do not return an error statement, if a goto misses its label argument, but create an anonymous label instead.

Do not return an error statement from parse_ms_try_statment(), just keep on parsing.

Do not refetch a value, which we already have.

Do not refetch a value, which we already have.

Reduce variable scope.

Do not refetch a value, which we already have.

Only use the skipped type, the unskipped type is useless here.

Move the GNU special case for sizeof(function) from sizeof_to_firm() to get_type_size().

Factorise the code to parse conditions of statements, i.e. an expression enclosed in parentheses.

This addresses several issues:
- No null pointer as condition anymore, if a if lacks its (.
- No anchor leak anymore, if a switch lacks its ).
- Better error recovery: No error statement anymore, if any part of a condition is missing.
- Less code duplication.

Remove dead assignment and the stale assert, which checked for the dead value, with it.

Move adding/removing ';' as anchor from intern_parse_statement() to parse_compound_statement().

It is already an anchor at {.S*} and then needs not to be repeated in intern_parse_statement() (and only adding ';' is a bit poor).

Discard all non-anchors from the input, not just the first one.

Push the special case for compound types into get_ir_mode_storage().

It already had a special case for array types, now it handles all non-scalar types.

adjust to latest libfirm debugoutput

Adjust cparser to extended debug information retrieval of libFirm, which includes the column.

Simplify and reduce code duplication in return_statement_to_firm().

Use the cparser type instead of the Firm type in return_statement_to_firm().

Reduce code duplication in layout_struct_type().

Remove the macro constant INVALID_TYPE, which is only used in comparisons, but never assigned.

Adhere an obscure C++ rule: typedef T void; void f(T) {} is not a valid way to declare an empty parameter list.

Use is_type_void(x) instead of x == type_void where qualified versions of void might occur.

Improve the error message if a qualified void type is used to denote an empty parameter list.

Replace is_type_atomic(x, ATOMIC_TYPE_VOID) by the more concise is_type_void(x).

Remove the unused variables ir_type_void and ir_type_int.

Factorise code to conditionally print an error or a warning.

Correct semantic check in parse_return(): A condition was inverted.

Do not get the break block of a switch before it is sure that a jump there is actually created.

Usually the inner (compound) statement of a switch ends in a break or return, so there is no normal flow out of the switch statement.

Split jump_if_reachable() into jump_to() and jump_if_reachable().

- jump_to() does what jump_if_reachable() did before, i.e. create a Bad if the source is unreachable.
- jump_if_reachable() does nothing if the source is unreachable.
- Document in which case which of these two functions needs to be used.
- This prevents Bad predecessors in the usual cases, e.g. non-fallthrough case labels.

It is not necessary to remember the switch block to create the default Proj at the end.

Simplify compound_statement_to_firm() by letting statement_to_firm() return an ir_node* instead of just expression_statement_to_firm().

Fix walk_statement(): Walk the expression(s) of case labels, too.

Reformat _expression_to_firm() for better readability.

Rename EXPR_REFERENCE_ENUM_VALUE to EXPR_ENUM_CONSTANT.

This is closer to what the C standard calls it (enumeration constant).

Shorten the edgaresque name reference_expression_enum_value_to_firm() to enum_constant_to_firm().

This comes close to what the C standard calls it (enumeration constant).

Remove special cases for EXPR_ERROR and TYPE_ERROR from constant folding and type construction.

We do not fold expressions containing errors anymore.

Remove duplicate assertion.

The subsequent call to fold_constant_to_tarval() checks the same.

Remove unnecessary assertion.

A subsequent assertion checks more.

Use fold_constant_to_tarval() instead of reimplementing it badly, i.e. failing with -O0.

Use create_Const_from_bool() instead of duplicating it.

Move a case, which unnecessarily was an explicit if, into the following switch.

Reformat statement_to_firm() for better readability.

Use create_jump_statement() to construct IR for goto statements.

Remove anchors only when they were added before.

Correct expression_to_firm() for compound literals.

Correct the ir_relation used for implicit comparisons with 0.

For floats checking for unordered is necessary.

Simplify if_statement_to_firm() so it in particular does not create a critical edge, if there is no else part.

- The then part is constructed before the else part now.
- No explicit block after the if statement is created if the then or else parts do not jump there.

Set the correct length for literal suffixes, i.e. do not count the terminating NUL.

Split computed gotos (STATEMENT_COMPUTED_GOTO) from normal goto statements.

Fix: Walk the expression of computed goto statements, too.

Reformat switches for better readability.

Make our multi-case macros nicer for code beautifiers.

Add EXPR_ERROR to the precedence list.

Simplify printing the seperator (", ") between call arguments.

Use for () where it is better suited than while ().

Use print_char('x') instead of print_string("x").

Improve printing after an inner statement.

Now we print
  if (x) {
  } else {
  }
instead of
  if (x) {
  }
  else {
  }

Ensure that case labels are always printed with the same indentation as their switch.

Now we print
  switch (x) {
  case 0:
   if (y) {
  case 1:
   f();
   }
  }
instead of
  switch (x) {
  case 0:
   if (y) {
   case 1:
   f();
   }
  }

Handle printing of inner statements systematically and correct/improve the output.

- Now we print
    if (x)
     f();
    else
     g();
  instead of
    if (x) f();
    else g();

- If cascades are still printed as
    if (x) {
    } else if (y) {
    }

- This corrects indendation when {case,default,goto} labels are inner statements.

Handle printing of indentation before statements more systematically and reduce code duplication.

This corrects the indentation if case labels and goto labels are interspersed or if there are consecutive goto labels.

Let the callers of print_statement() handle printing a newline at the end.

Remove pointless null pointer check.

Case label statements always have an inner statement.

ignore config.mak

fix -O0 still performing local optimizations

update libfirm version

ignore -msse2

rework os classification

ignore TARGET environment variable (Makefiles tend to set that and confuse cparser)

update libfirm reference (so new builtins actually work)

implement more builtins

(bswap, fabs)

darwin name in target tripple may contain version

update libfirm reference

update for new release

disable download from internet in makefile for now

implement -dumpversion for gcc compatibility

fix --help display

Fixed wrong enum type.

maturing start and end block isn't necessary anymore with latest libfirm

do not use ir_.*_ptr types

Do not link on every make invocation

Previously, ld had to be called, because the static libfirm might have
been updated.

Note the little hack, which apparently makes GNU Make re-evaluated the
Makefile, whenever the phony libfirm_subdir goal has been executed:

> Makefile: libfirm_subdir

fix noreturn attribute

ignore gcc --unroll-loops

update NEWS, README

fix warnings

compound literals are linker_constants

fix non-scalar type initializers

create constant initializers as entities in data segment

cleanup driver interface a bit

the frontend shouldn't care about the inliner

always put a mode into assembler constraints

use ir_export_file so we can also export to stdout