Remove old scope/type/value analysis, fix omissions where Declaration.storage_class was not set and formal parameters were not analyzed by new type analysis

Set up a way of comparing the old scope/type/value analysis result with the new, fix a large number of bugs in both the old and the new so that they match up

Add value_analysis() method, called from post_process() after type_analysis()

Move ExpressionCall parameters coercion from calc_type() into type_analysis()

In /post_process.py and /type_analysis.py implement initializer stack, in /ansi_c.[ty] and /pretty_print.t remove the InitializerOrExpression base class in favour of wrapping initializer expressions in an extra InitializerExpression node

Add post_process.Context object, to track return type and switch case type

Make type_analysis() also call calc_type() and add_cast() on Expression nodes

Add type_analysis() method, called from post_process() in post-order

Implement post_process() which recurses through the tree calling scope_analysis(), the scope_analysis() routine now just processes one node with no recursion

Modify scope_analysis() to process the tree in strict pre-order

Add location tracking, syntax error and invalid character reporting

Move code out of ansi_c.t into base_type.py, calc_type.py, calc_value.py, declarator.py, storage_class.py

New scope analysis in a separate module (clobbers the type analysis currently)

New way of tracking typedef names so that the full scope analysis can be moved out of the parser and into a separate pass, rationalize DeclaratorFunction and TypeFunction everywhere so that both have derived classes for ANSI or KAndR

Make typedef processing occur by intercepting yylex(), it is much simpler

In /pretty_print.t reorder the methods so that e.g. InitDeclaratorList comes after InitDeclarator (my script had placed these backwards when one was a prefix of another) and fix a bug with StatementFor occurring twice, in /*.[ty] change ArrayOrStructOrUnion to ArrayOrStruct and StatementIfElse to StatementIf, in /ansi_c.y fix bugs with missing %space before (?E{MemberIdentifier}IDENTIFIER)

Rename /vm_test.asm to /vm_test_128.asm, implement 64-bit and 32-bit versions

In /vm_asm.py implement imm.iXX and imm.fXX constant optimization using cvt.XX

In /vm_test.asm use "offpc label@" instead of "imm.i32 label" for a significant space saving, in /vm_asm.py improve the listing file with auto operands

In /vm_test.asm add square-root calculation routine

In /vm_test.asm add floating-point printing routine, in /vm.c fix order of operands for the non-commutative operators sub(.r), div(.r|.u|.u.r) and relational operators, in /vm.c and /vm_asm.py add the forgotten mod(.r|.u|.u.r) operator (%)

In /vm_test.asm, add more test routines

In /vm_asm.py, add the ability to assemble float128 numbers

Add stack-based VM for testing

In pretty printer, improve how base types are generated and structs printed

Rationalize new scopes so they are only defined by an ItemList which can be either a TranslationUnit or a BlockItemList, make the definitions of enums, structs and unions from each new scope be output at the start of the ItemList

Fix a bug which prevented (void) argument list from pretty printing correctly

Fix a bug which prevented the -> operator from pretty printing correctly

Add indenting in the pretty printer

Add declarator precedence in the pretty printer

Add expression precedence in the pretty printer

Rationalize how ParameterDeclaration is handled in both the parser (convert to a name, type pair as soon as it is parsed and then use this later to build the TypeFunctionANSI), and the pretty printer (attach the names to the parameters)

First cut at pretty printer, fix minor inconsistencies in ansi_c.[ty]

Add the Node.strip_redundancy() method, removes all text, declarators, etc

Support array or struct/union literals in expressions

Add TagIdentifier class and extra annotations for array or struct/union indices

For array of indeterminate size with initializer, deduce the size

Remove rough Expression.get_const_value() in favour of Expression.value

Add type analysis for initializers, add some extra (s)size_t and bool casts

Implement mostly complete type analysis and constant folding, compiles nbench

Implement (un)signed_int_value() and float_value() for constructing Value objects directly with a specified precision, instead of cumbersome Value.cast() idea

Implement build() in ansi_c.[ly] to make type analysis and constant folding occur during parsing instead, requires new skeleton code from latest pilex, pitree

Add an extra pass for type analysis and constant folding, doesn't support all operators and has just enough implementation to compile the example test.i file

Implement the value field for character constants and string literals

Update ansi_c.t for latest pitree, it has default value bug fixed and adds MPFR

Upgrade lexical analyzer to implement the C90 rules explicitly and to add markup to the individual parts of constants, strings etc, add number handling facilities so that we can store the type and (if constant) the value on an expression

Add the lex_yy.mask_typedefs flag so that typedef processing can be masked for the identifier following a "struct", "union", "enum", "." or "->" keyword, fix a bug where the scope_(struct|union|enum)_tag was not declared and saved in XML

Refactor parsing of function definitions so that the function is added to the scope as soon as we see the definition, hence can call itself without a prototype

Make DeclaratorIdentifier store the identifier text directly in the same way as ExpressionIdentifier does, make specifier list processing slightly more strict

Add /nbench containing source for the nbench benchmark from math.utah.edu/~mayer/linux/nbench-byte-2.2.3.tar.gz preprocessed with musl-gcc from https://musl.libc.org/releases/musl-1.2.4.tar.gz, make the analysis cope with all constructs in this code except for some very tiny workarounds labeled /* Nick */

Initial commit, has scope analysis and beginnings of type analysis