Add dependencies/vendor (whatsapp)

1 files changed, 1033 insertions, 0 deletions

diff --git a/vendor/modernc.org/cc/v3/parser.yy b/vendor/modernc.org/cc/v3/parser.yy
new file mode 100644
index 00000000..a51b600b
--- /dev/null
+++ b/vendor/modernc.org/cc/v3/parser.yy
@@ -0,0 +1,1033 @@
+%{
+// Copyright 2019 The CC Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Based on [0], 6.5-6.10. 
+
+package cc // import "modernc.org/cc/v3"
+
+%}
+
+%union {
+	Token			Token
+	node			Node
+}
+
+%token
+	/*yy:token "%c"		*/	IDENTIFIER
+	/*yy:token "%c_e"	*/	ENUMCONST
+	/*yy:token "%c_t"	*/	TYPEDEFNAME
+	/*yy:token "%d"		*/	INTCONST
+	/*yy:token "'%c'"	*/	CHARCONST
+	/*yy:token "1.%d"	*/	FLOATCONST
+	/*yy:token "L'%c'"	*/	LONGCHARCONST
+	/*yy:token "L\"%c\""	*/	LONGSTRINGLITERAL
+	/*yy:token "\"%c\""	*/	STRINGLITERAL
+
+	ACCUM			"_Accum"
+	ADDASSIGN		"+="
+	ALIGNAS			"_Alignas"
+	ALIGNOF			"_Alignof"
+	ANDAND			"&&"
+	ANDASSIGN		"&="
+	ARROW			"->"
+	ASM			"__asm__"
+	ATOMIC			"_Atomic"
+	ATTRIBUTE		"__attribute__"
+	AUTO			"auto"
+	BOOL			"_Bool"
+	BREAK			"break"
+	BUILTINCHOOSEXPR	"__builtin_choose_expr"
+	BUILTINTYPESCOMPATIBLE	"__builtin_types_compatible_p"
+	CASE			"case"
+	CHAR			"char"
+	COMPLEX			"_Complex"
+	CONST			"const"
+	CONTINUE		"continue"
+	DDD			"..."
+	DEC			"--"
+	DECIMAL128		"_Decimal128"
+	DECIMAL32		"_Decimal32"
+	DECIMAL64		"_Decimal64"
+	DEFAULT			"default"
+	DIVASSIGN		"/="
+	DO			"do"
+	DOUBLE			"double"
+	ELSE			"else"
+	ENUM			"enum"
+	EQ			"=="
+	EXTERN			"extern"
+	FLOAT			"float"
+	FLOAT128		"_Float128"
+	FLOAT16			"__fp16"
+	FLOAT32			"_Float32"
+	FLOAT32X		"_Float32x"
+	FLOAT64			"_Float64"
+	FLOAT64x		"_Float64x"
+	FLOAT80			"__float80"
+	FOR			"for"
+	FRACT			"_Fract"
+	GEQ			">="
+	GOTO			"goto"
+	IF			"if"
+	IMAG			"__imag__"
+	INC			"++"
+	INLINE			"inline"
+	INT			"int"
+	INT8			"__int8"
+	INT16			"__int16"
+	INT32			"__int32"
+	INT64			"__int64"
+	INT128			"__int128"
+	LABEL			"__label__"
+	LEQ			"<="
+	LONG			"long"
+	LSH			"<<"
+	LSHASSIGN		"<<="
+	MODASSIGN		"%="
+	MULASSIGN		"*="
+	NEQ			"!="
+	NORETURN		"_Noreturn"
+	ORASSIGN		"|="
+	OROR			"||"
+	PPNUMBER		"preprocessing number"
+	PPPASTE			"##"
+	PRAGMASTDC		"__pragma_stdc"
+	REAL			"__real__"
+	REGISTER		"register"
+	RESTRICT		"restrict"
+	RETURN			"return"
+	RSH			">>"
+	RSHASSIGN		">>="
+	SAT			"_Sat"
+	SHORT			"short"
+	SIGNED			"signed"
+	SIZEOF			"sizeof"
+	STATIC			"static"
+	STRUCT			"struct"
+	SUBASSIGN		"-="
+	SWITCH			"switch"
+	THREADLOCAL		"_Thread_local"
+	TYPEDEF			"typedef"
+	TYPEOF			"typeof"
+	UNION			"union"
+	UNSIGNED		"unsigned"
+	VOID			"void"
+	VOLATILE		"volatile"
+	WHILE			"while"
+	XORASSIGN		"^="
+
+%precedence	BELOW_ELSE
+%precedence	ELSE
+
+%precedence	BELOW_ATTRIBUTE
+%precedence	ATTRIBUTE
+
+%start TranslationUnit
+
+%%
+
+		        /* [0], 6.5.1 Primary expressions */
+			/*yy:field	Operand			Operand	*/
+			/*yy:field	lexicalScope		Scope	*/
+			/*yy:field	resolvedIn		Scope	*/
+			/*yy:field	resolvedTo		Node	*/
+			/*yy:field	IsSideEffectsFree	bool	*/
+			/*yy:example int i = x; */
+/*yy:case Ident      */
+			PrimaryExpression:
+				IDENTIFIER
+			/*yy:example int i = 42; */
+/*yy:case Int        */ |	INTCONST
+			/*yy:example int i = 3.14; */
+/*yy:case Float      */ |	FLOATCONST
+			/*yy:example enum e {a}; int i = a; */
+/*yy:case Enum       */ |	ENUMCONST
+			/*yy:example int i = 'x'; */
+/*yy:case Char       */ |	CHARCONST
+			/*yy:example int i = L'x'; */
+/*yy:case LChar      */ |	LONGCHARCONST
+			/*yy:example char *c = "x"; */
+/*yy:case String     */ |	STRINGLITERAL
+			/*yy:example char *c = L"x"; */
+/*yy:case LString    */ |	LONGSTRINGLITERAL
+			/*yy:example int i = (x+y); */
+/*yy:case Expr       */ |	'(' Expression ')'
+			/*yy:example int i = ({x();}); */
+/*yy:case Stmt       */	|	'(' CompoundStatement ')'
+
+		        /* [0], 6.5.2 Postfix operators */
+			/*yy:field	Operand			Operand	*/
+			/*yy:field	Field			Field	// Case Select, PSelect */
+			/*yy:field	IsSideEffectsFree	bool	*/
+			/*yy:example int i = x; */
+/*yy:case Primary    */ PostfixExpression:
+				PrimaryExpression
+			/*yy:example int i = x[y]; */
+/*yy:case Index      */ |	PostfixExpression '[' Expression ']'
+			/*yy:example int i = x(y); */
+/*yy:case Call       */ |	PostfixExpression '(' ArgumentExpressionList ')'
+			/*yy:example int i = x.y; */
+/*yy:case Select     */ |	PostfixExpression '.' IDENTIFIER
+			/*yy:example int i = x->y; */
+/*yy:case PSelect    */ |	PostfixExpression "->" IDENTIFIER
+			/*yy:example int i = x++; */
+/*yy:case Inc        */ |	PostfixExpression "++"
+			/*yy:example int i = x--; */
+/*yy:case Dec        */ |	PostfixExpression "--"
+			/*yy:example int i = (int[]){y}; */
+/*yy:case Complit    */ |	'(' TypeName ')' '{' InitializerList ',' '}'
+			/*yy:example int i = __builtin_types_compatible_p(int, double); */
+/*yy:case TypeCmp   */  |	"__builtin_types_compatible_p" '(' TypeName ',' TypeName ')'
+			/*yy:example int i = __builtin_choose_expr(1, 2, "foo"); */
+/*yy:case ChooseExpr*/  |	"__builtin_choose_expr" '(' AssignmentExpression ',' AssignmentExpression ',' AssignmentExpression ')'
+
+			/*yy:example int i = f(x); */
+			ArgumentExpressionList:
+				AssignmentExpression
+			/*yy:example int i = f(x, y); */
+			|	ArgumentExpressionList ',' AssignmentExpression
+
+			/* [0], 6.5.3 Unary operators */
+			/*yy:field	Operand			Operand	*/
+			/*yy:field	lexicalScope		Scope	*/
+			/*yy:field	IsSideEffectsFree	bool	*/
+			/*yy:example int i = x; */
+/*yy:case Postfix    */ UnaryExpression:
+				PostfixExpression
+			/*yy:example int i = ++x; */
+/*yy:case Inc        */ |	"++" UnaryExpression
+			/*yy:example int i = --x; */
+/*yy:case Dec        */ |	"--" UnaryExpression
+			/*yy:example int *i = &x; */
+/*yy:case Addrof     */ |	'&' CastExpression
+			/*yy:example int i = *x; */
+/*yy:case Deref      */ |	'*' CastExpression
+			/*yy:example int i = +x; */
+/*yy:case Plus       */ |	'+' CastExpression
+			/*yy:example int i = -x; */
+/*yy:case Minus      */ |	'-' CastExpression
+			/*yy:example int i = ~x; */
+/*yy:case Cpl        */ |	'~' CastExpression
+			/*yy:example int i = !x; */
+/*yy:case Not        */ |	'!' CastExpression
+			/*yy:example int i = sizeof x; */
+/*yy:case SizeofExpr */ |	"sizeof" UnaryExpression
+			/*yy:example int i = sizeof(int); */
+/*yy:case SizeofType */ |	"sizeof" '(' TypeName ')'
+			/*yy:example int f() { L: &&L; }*/
+/*yy:case LabelAddr  */ |	"&&" IDENTIFIER
+			/*yy:example int i = _Alignof(x); */
+/*yy:case AlignofExpr*/ |	"_Alignof" UnaryExpression
+			/*yy:example int i = _Alignof(int); */
+/*yy:case AlignofType*/ |	"_Alignof" '(' TypeName ')'
+			/*yy:example double i = __imag__ x; */
+/*yy:case Imag       */ |	"__imag__" UnaryExpression
+			/*yy:example double i = __real__ x; */
+/*yy:case Real       */ |	"__real__" UnaryExpression
+
+			/* [0], 6.5.4 Cast operators */
+			/*yy:field	Operand			Operand	*/
+			/*yy:field	IsSideEffectsFree	bool	*/
+			/*yy:example int i = 42; */
+/*yy:case Unary      */ CastExpression:
+				UnaryExpression
+			/*yy:example int i = (int)3.14; */
+/*yy:case Cast       */ |	'(' TypeName ')' CastExpression
+
+			/* [0], 6.5.5 Multiplicative operators */
+			/*yy:field	Operand			Operand	*/
+			/*yy:field	promote			Type	*/
+			/*yy:field	IsSideEffectsFree	bool	*/
+			/*yy:example int i = x;*/
+/*yy:case Cast       */ MultiplicativeExpression:
+				CastExpression
+			/*yy:example int i = x * y;*/
+/*yy:case Mul        */ |	MultiplicativeExpression '*' CastExpression
+			/*yy:example int i = x / y;*/
+/*yy:case Div        */ |	MultiplicativeExpression '/' CastExpression
+			/*yy:example int i = x % y;*/
+/*yy:case Mod        */ |	MultiplicativeExpression '%' CastExpression
+
+			/* [0], 6.5.6 Additive operators */
+			/*yy:field	lexicalScope		Scope	*/
+			/*yy:field	Operand			Operand	*/
+			/*yy:field	promote			Type	*/
+			/*yy:field	IsSideEffectsFree	bool	*/
+			/*yy:example int i = x; */
+/*yy:case Mul        */ AdditiveExpression:
+				MultiplicativeExpression
+			/*yy:example int i = x+y; */
+/*yy:case Add        */ |	AdditiveExpression '+' MultiplicativeExpression
+			/*yy:example int i = x-y; */
+/*yy:case Sub        */ |	AdditiveExpression '-' MultiplicativeExpression
+
+			/* [0], 6.5.7 Bitwise shift operators */
+			/*yy:field	Operand			Operand	*/
+			/*yy:field	promote			Type	// shift count promoted type */
+			/*yy:field	IsSideEffectsFree	bool	*/
+			/*yy:example int i = x; */
+/*yy:case Add        */ ShiftExpression:
+				AdditiveExpression
+			/*yy:example int i = x << y; */
+/*yy:case Lsh        */ |	ShiftExpression "<<" AdditiveExpression
+			/*yy:example int i = x >> y; */
+/*yy:case Rsh        */ |	ShiftExpression ">>" AdditiveExpression
+
+			/* [0], 6.5.8 Relational operators */
+			/*yy:field	Operand			Operand	*/
+			/*yy:field	promote			Type	*/
+			/*yy:field	IsSideEffectsFree	bool	*/
+			/*yy:example int i = x; */
+/*yy:case Shift      */ RelationalExpression:
+				ShiftExpression        
+			/*yy:example int i = x < y; */
+/*yy:case Lt         */ |	RelationalExpression '<'  ShiftExpression
+			/*yy:example int i = x > y; */
+/*yy:case Gt         */ |	RelationalExpression '>'  ShiftExpression
+			/*yy:example int i = x <= y; */
+/*yy:case Leq        */ |	RelationalExpression "<=" ShiftExpression
+			/*yy:example int i = x >= y; */
+/*yy:case Geq        */ |	RelationalExpression ">=" ShiftExpression
+
+			/* [0], 6.5.9 Equality operators */
+			/*yy:field	Operand			Operand	*/
+			/*yy:field	promote			Type	*/
+			/*yy:field	IsSideEffectsFree	bool	*/
+			/*yy:example int i = x; */
+/*yy:case Rel        */ EqualityExpression:
+				RelationalExpression
+			/*yy:example int i = x == y; */
+/*yy:case Eq         */ |	EqualityExpression "==" RelationalExpression
+			/*yy:example int i = x != y; */
+/*yy:case Neq        */ |	EqualityExpression "!=" RelationalExpression
+
+			/* [0], 6.5.10 Bitwise AND operator */
+			/*yy:field	Operand			Operand	*/
+			/*yy:field	promote			Type	*/
+			/*yy:field	IsSideEffectsFree	bool	*/
+			/*yy:example int i = x; */
+/*yy:case Eq         */ AndExpression:
+				EqualityExpression
+			/*yy:example int i = x & y; */
+/*yy:case And        */ |	AndExpression '&' EqualityExpression
+
+			/* [0], 6.5.11 Bitwise exclusive OR operator */
+			/*yy:field	Operand			Operand	*/
+			/*yy:field	promote			Type	*/
+			/*yy:field	IsSideEffectsFree	bool	*/
+			/*yy:example int i = x; */
+/*yy:case And        */ ExclusiveOrExpression:
+				AndExpression
+			/*yy:example int i = x^y; */
+/*yy:case Xor        */ |	ExclusiveOrExpression '^' AndExpression
+
+			/* [0], 6.5.12 Bitwise inclusive OR operator */
+			/*yy:field	Operand			Operand	*/
+			/*yy:field	promote			Type	*/
+			/*yy:field	IsSideEffectsFree	bool	*/
+			/*yy:example int i = x; */
+/*yy:case Xor        */ InclusiveOrExpression:
+				ExclusiveOrExpression
+			/*yy:example int i = x|y; */
+/*yy:case Or         */ |	InclusiveOrExpression '|' ExclusiveOrExpression
+
+			/* [0], 6.5.13 Logical AND operator */
+			/*yy:field	Operand			Operand	*/
+			/*yy:field	IsSideEffectsFree	bool	*/
+			/*yy:example int i = x;*/
+/*yy:case Or         */ LogicalAndExpression:
+				InclusiveOrExpression
+			/*yy:example int i = x && y;*/
+/*yy:case LAnd       */ |	LogicalAndExpression "&&" InclusiveOrExpression
+
+			/* [0], 6.5.14 Logical OR operator */
+			/*yy:field	Operand			Operand	*/
+			/*yy:field	IsSideEffectsFree	bool	*/
+			/*yy:example int i = x;*/
+/*yy:case LAnd       */ LogicalOrExpression:
+				LogicalAndExpression
+			/*yy:example int i = x || y;*/
+/*yy:case LOr        */ |	LogicalOrExpression "||" LogicalAndExpression
+
+			/* [0], 6.5.15 Conditional operator */
+			/*yy:field	Operand			Operand	*/
+			/*yy:field	IsSideEffectsFree	bool	*/
+			/*yy:example int i = x; */
+/*yy:case LOr        */ ConditionalExpression:
+				LogicalOrExpression
+			/*yy:example int i = x ? y : z; */
+/*yy:case Cond       */ |	LogicalOrExpression '?' Expression ':' ConditionalExpression
+
+			/* [0], 6.5.16 Assignment operators */
+			/*yy:field	Operand			Operand	*/
+			/*yy:field	InitializerOperand	Operand	// When the expression is used in an initializer */
+			/*yy:field	lexicalScope		Scope	*/
+			/*yy:field	promote			Type	*/
+			/*yy:field	IsSideEffectsFree	bool	*/
+			/*yy:example int i = x; } */
+/*yy:case Cond       */ AssignmentExpression:
+				ConditionalExpression
+			/*yy:example int f() { x = y; } */
+/*yy:case Assign     */ |	UnaryExpression '=' AssignmentExpression
+			/*yy:example int f() { x *= y; } */
+/*yy:case Mul        */ |	UnaryExpression "*=" AssignmentExpression
+			/*yy:example int f() { x /= y; } */
+/*yy:case Div        */ |	UnaryExpression "/=" AssignmentExpression
+			/*yy:example int f() { x %= y; } */
+/*yy:case Mod        */ |	UnaryExpression "%=" AssignmentExpression
+			/*yy:example int f() { x += y; } */
+/*yy:case Add        */ |	UnaryExpression "+=" AssignmentExpression
+			/*yy:example int f() { x -= y; } */
+/*yy:case Sub        */ |	UnaryExpression "-=" AssignmentExpression
+			/*yy:example int f() { x <<= y; } */
+/*yy:case Lsh        */ |	UnaryExpression "<<=" AssignmentExpression
+			/*yy:example int f() { x >>= y; } */
+/*yy:case Rsh        */ |	UnaryExpression ">>=" AssignmentExpression
+			/*yy:example int f() { x &= y; } */
+/*yy:case And        */ |	UnaryExpression "&=" AssignmentExpression
+			/*yy:example int f() { x ^= y; } */
+/*yy:case Xor        */ |	UnaryExpression "^=" AssignmentExpression
+			/*yy:example int f() { x |= y; } */
+/*yy:case Or         */ |	UnaryExpression "|=" AssignmentExpression
+
+			/* [0], 6.5.17 Comma operator */
+			/*yy:field	Operand			Operand	*/
+			/*yy:field	IsSideEffectsFree	bool	*/
+			/*yy:example int f() { i = x; }; */
+/*yy:case Assign     */ Expression:
+				AssignmentExpression
+			/*yy:example int f() { x, y; }; */
+/*yy:case Comma      */ |	Expression ',' AssignmentExpression
+
+			/* [0], 6.6 Constant expressions */
+			/*yy:field	Operand		Operand	*/
+			/*yy:example struct { int i:3; }; */
+			ConstantExpression:
+				ConditionalExpression
+
+			/* [0], 6.7 Declarations */
+			/*yy:example int i, j; */
+			Declaration:
+				DeclarationSpecifiers InitDeclaratorList ';'
+
+			/*yy:field	class	storageClass	*/
+			/*yy:example static int i; */
+/*yy:case Storage    */ DeclarationSpecifiers:
+				StorageClassSpecifier DeclarationSpecifiers
+			/*yy:example int i; */
+/*yy:case TypeSpec   */ |	TypeSpecifier DeclarationSpecifiers
+			/*yy:example volatile int i; */
+/*yy:case TypeQual   */ |	TypeQualifier DeclarationSpecifiers
+			/*yy:example inline int f() {} */
+/*yy:case Func       */ |	FunctionSpecifier DeclarationSpecifiers
+			/*yy:example _Alignas(double) int i; */
+/*yy:case AlignSpec  */ |	AlignmentSpecifier DeclarationSpecifiers
+			/*yy:example int __attribute__((a)) i; */
+/*yy:case Attribute  */ |	AttributeSpecifier DeclarationSpecifiers
+
+			/*yy:example int i; */
+			InitDeclaratorList:
+				InitDeclarator
+			/*yy:example int i, j; */
+			|	InitDeclaratorList ',' AttributeSpecifierList InitDeclarator
+
+			/*yy:field	initializer	*InitializerValue */
+			/*yy:example int i; */
+/*yy:case Decl       */ InitDeclarator:
+				Declarator AttributeSpecifierList
+			/*yy:example int i = x; */
+/*yy:case Init       */ |	Declarator AttributeSpecifierList '=' Initializer
+
+			/* [0], 6.7.1 Storage-class specifiers */
+			/*yy:example typedef int int_t;*/
+/*yy:case Typedef    */ StorageClassSpecifier:
+				"typedef"
+			/*yy:example extern int i;*/
+/*yy:case Extern     */ |	"extern"
+			/*yy:example static int i;*/
+/*yy:case Static     */ |	"static"
+			/*yy:example auto int i;*/
+/*yy:case Auto       */ |	"auto"
+			/*yy:example register int i;*/
+/*yy:case Register   */ |	"register"
+			/*yy:example _Thread_local int i;*/
+/*yy:case ThreadLocal*/ |	"_Thread_local"
+
+			/* [0], 6.7.2 Type specifiers */
+			/*yy:field	resolvedIn	Scope	// Case TypedefName */
+			/*yy:field	typ		Type */
+			/*yy:example void i(); */
+/*yy:case Void       */ TypeSpecifier:
+				"void"
+			/*yy:example char i; */
+/*yy:case Char       */ |	"char"
+			/*yy:example short i; */
+/*yy:case Short      */ |	"short"
+			/*yy:example int i; */
+/*yy:case Int        */ |	"int"
+			/*yy:example __int8 i; */
+/*yy:case Int8     */ |	"__int8"
+			/*yy:example __int16 i; */
+/*yy:case Int16     */ |	"__int16"
+			/*yy:example __int32 i; */
+/*yy:case Int32     */ |	"__int32"
+			/*yy:example __int64 i; */
+/*yy:case Int64     */ |	"__int64"
+			/*yy:example __int128 i; */
+/*yy:case Int128     */ |	"__int128"
+			/*yy:example long i; */
+/*yy:case Long       */ |	"long"
+			/*yy:example float i; */
+/*yy:case Float      */ |	"float"
+			/*yy:example __fp16 i; */
+/*yy:case Float16    */ |	"__fp16"
+			/*yy:example _Decimal32 i; */
+/*yy:case Decimal32  */ |	"_Decimal32"
+			/*yy:example _Decimal64 i; */
+/*yy:case Decimal64  */ |	"_Decimal64"
+			/*yy:example _Decimal128 i; */
+/*yy:case Decimal128 */ |	"_Decimal128"
+			/*yy:example _Float128 i; */
+/*yy:case Float128   */ |	"_Float128"
+			/*yy:example __float80 i; */
+/*yy:case Float80    */ |	"__float80"
+			/*yy:example double i; */
+/*yy:case Double     */ |	"double"
+			/*yy:example signed i; */
+/*yy:case Signed     */ |	"signed"
+			/*yy:example unsigned i; */
+/*yy:case Unsigned   */ |	"unsigned"
+			/*yy:example _Bool i; */
+/*yy:case Bool       */ |	"_Bool"
+			/*yy:example _Complex i; */
+/*yy:case Complex    */ |	"_Complex"
+			/*yy:example struct s i; */
+/*yy:case StructOrUnion */
+			|	StructOrUnionSpecifier
+			/*yy:example enum e i; */
+/*yy:case Enum       */ |	EnumSpecifier
+			/*yy:example typedef const T; T i; */
+/*yy:case TypedefName*/ |	TYPEDEFNAME
+			/*yy:example typeof(42) i; */
+/*yy:case TypeofExpr */ |	"typeof" '(' Expression ')'
+			/*yy:example typedef const T; typeof(T) i; */
+/*yy:case TypeofType */ |	"typeof" '(' TypeName ')'
+			/*yy:example _Atomic(int) i; */
+/*yy:case Atomic     */ |	AtomicTypeSpecifier
+			/*yy:example _Fract i; */
+/*yy:case Fract      */ |	"_Fract"
+			/*yy:example _Sat i; */
+/*yy:case Sat        */ |	"_Sat"
+			/*yy:example _Accum i; */
+/*yy:case Accum      */ |	"_Accum"
+			/*yy:example _Float32 i; */
+/*yy:case Float32    */ |	"_Float32"
+			/*yy:example _Float64 i; */
+/*yy:case Float64    */ |	"_Float64"
+			/*yy:example _Float32x i; */
+/*yy:case Float32x    */ |	"_Float32x"
+			/*yy:example _Float64x i; */
+/*yy:case Float64x    */ |	"_Float64x"
+
+			/* [0], 6.7.2.1 Structure and union specifiers */
+			/*yy:field	lexicalScope	Scope	*/
+			/*yy:field	maxAlign	int	*/
+			/*yy:field	typ		Type */
+			/*yy:example struct s { int i; }; */
+/*yy:case Def        */ StructOrUnionSpecifier:
+				StructOrUnion AttributeSpecifierList IDENTIFIER '{' StructDeclarationList '}'
+			/*yy:example struct s v; */
+/*yy:case Tag        */ |	StructOrUnion AttributeSpecifierList IDENTIFIER
+
+			/*yy:example struct { int i; } s; */
+/*yy:case Struct     */ StructOrUnion:
+				"struct"
+			/*yy:example union { int i; double d; } u; */
+/*yy:case Union      */ |	"union"
+		
+			/*yy:example struct{ int i; } */
+			StructDeclarationList:
+				StructDeclaration
+			/*yy:example struct{ int i; double d; } */
+			|	StructDeclarationList StructDeclaration
+		
+			/*yy:example struct{ int i; } */
+			/*yy:field	Empty		bool // TCC extension */
+			StructDeclaration:
+				SpecifierQualifierList StructDeclaratorList ';'
+		
+			/*yy:field	noStorageClass */
+			/*yy:example struct {int i;};*/
+/*yy:case TypeSpec   */ SpecifierQualifierList:
+				TypeSpecifier SpecifierQualifierList
+			/*yy:example struct {const int i;};*/
+/*yy:case TypeQual   */ |	TypeQualifier SpecifierQualifierList
+			/*yy:example struct {_Alignas(double) int i;};*/
+/*yy:case AlignSpec  */ |	AlignmentSpecifier SpecifierQualifierList
+			/*yy:example struct {__attribute__((a)) int i;};*/
+/*yy:case Attribute  */ |	AttributeSpecifier SpecifierQualifierList
+
+			/*yy:example struct{ int i; } */
+			StructDeclaratorList:
+				StructDeclarator
+			/*yy:example struct{ int i, j; } */
+			|	StructDeclaratorList ',' StructDeclarator
+		
+			/*yy:field	decl *StructDeclaration */
+			/*yy:example struct{ int i; } */
+/*yy:case Decl       */ StructDeclarator:
+				Declarator
+			/*yy:example struct{ int i:3; } */
+/*yy:case BitField   */ |	Declarator ':' ConstantExpression AttributeSpecifierList
+
+			/* [0], 6.7.2.2 Enumeration specifiers */
+			/*yy:field	lexicalScope	Scope	*/
+			/*yy:field	typ		Type */
+			/*yy:field	min		Value */
+			/*yy:field	max		Value */
+			/*yy:example enum e {a}; */
+/*yy:case Def        */ EnumSpecifier:
+				"enum" AttributeSpecifierList IDENTIFIER '{' EnumeratorList ',' '}'
+			/*yy:example enum e i; */
+/*yy:case Tag        */ |	"enum" AttributeSpecifierList IDENTIFIER
+
+			/*yy:example enum e {a}; */
+			EnumeratorList:
+				Enumerator
+			/*yy:example enum e {a, b}; */
+			|	EnumeratorList ',' Enumerator
+
+			/*yy:field	lexicalScope	Scope	*/
+			/*yy:field	Operand		Operand	*/
+			/*yy:example enum e {a}; */
+/*yy:case Ident      */ Enumerator:
+				IDENTIFIER AttributeSpecifierList
+			/*yy:example enum e {a = 42}; */
+/*yy:case Expr       */ |	IDENTIFIER AttributeSpecifierList '=' ConstantExpression
+
+			/* [2], 6.7.2.4 Atomic type specifiers */
+			/*yy:field	list	[]*TypeSpecifier */
+			/*yy:example    _Atomic(int) i; */
+			AtomicTypeSpecifier:
+				"_Atomic" '(' TypeName ')'
+
+			/* [0], 6.7.3 Type qualifiers */
+			/*yy:example const int i; */
+/*yy:case Const      */ TypeQualifier:
+				"const"
+			/*yy:example restrict int i; */
+/*yy:case Restrict   */ |	"restrict"
+			/*yy:example volatile int i; */
+/*yy:case Volatile   */ |	"volatile"
+			/*yy:example _Atomic int i; */
+/*yy:case Atomic     */ |	"_Atomic"
+
+			/* [0], 6.7.4 Function specifiers */
+			/*yy:example inline int f() {}*/
+/*yy:case Inline     */ FunctionSpecifier:
+				"inline"
+			/*yy:example _Noreturn int f() {}*/
+/*yy:case Noreturn   */ |	"_Noreturn"
+
+			/* [0], 6.7.5 Declarators */
+			/*yy:field	Linkage		Linkage		*/
+			/*yy:field	Read		int		*/
+			/*yy:field	StorageClass	StorageClass	*/
+			/*yy:field	Write		int		*/
+			/*yy:field	funcDefinition	*FunctionDefinition		*/
+			/*yy:field	lhs		map[*Declarator]struct{}	*/
+			/*yy:field	td		typeDescriptor	*/
+			/*yy:field	typ		Type		*/
+			/*yy:field	AddressTaken	bool		*/
+			/*yy:field	IsParameter	bool		*/
+			/*yy:field	IsTypedefName	bool		*/
+			/*yy:field	SubjectOfAsgnOp	bool		*/
+			/*yy:field	SubjectOfIncDec	bool		*/
+			/*yy:field	called		bool		*/
+			/*yy:field	fnDef		bool		*/
+			/*yy:field	hasInitializer	bool		*/
+			/*yy:field	implicit	bool		*/
+			/*yy:example int *p __attribute__ ((foo)); */
+			Declarator:
+				Pointer DirectDeclarator AttributeSpecifierList %prec BELOW_ATTRIBUTE
+
+			/* [2], 6.7.5 Alignment specifier */
+			/*yy:example _Alignas(double) char c; */
+/*yy:case AlignasType*/ AlignmentSpecifier:
+				"_Alignas" '(' TypeName ')'
+			/*yy:example _Alignas(0ll) char c; */
+/*yy:case AlignasExpr*/ |	"_Alignas" '(' ConstantExpression ')'
+
+			/*yy:field	lexicalScope		Scope	*/
+			/*yy:field	paramScope		Scope */
+			/*yy:field	typeQualifiers		*typeBase */
+			/*yy:field	idListNoDeclList	bool */
+			/*yy:example int i; */
+/*yy:case Ident      */ DirectDeclarator:
+				IDENTIFIER Asm
+			/*yy:example int (f); */
+/*yy:case Decl       */ |	'(' AttributeSpecifierList Declarator ')'
+			/*yy:example int i[const 42]; */
+/*yy:case Arr        */ |	DirectDeclarator '[' TypeQualifiers AssignmentExpression ']'
+			/*yy:example int i[static const 42]; */
+/*yy:case StaticArr  */ |	DirectDeclarator '[' "static" TypeQualifiers AssignmentExpression ']'
+			/*yy:example int i[const static 42]; */
+/*yy:case ArrStatic  */ |	DirectDeclarator '[' TypeQualifiers "static" AssignmentExpression ']'
+			/*yy:example int i[const *]; */
+/*yy:case Star       */ |	DirectDeclarator '[' TypeQualifiers '*' ']'
+			/*yy:example int f(int i); */
+/*yy:case FuncParam  */ |	DirectDeclarator '(' ParameterTypeList ')'
+			/*yy:example int f(a); */
+/*yy:case FuncIdent  */ |	DirectDeclarator '(' IdentifierList ')'
+
+			/*yy:field	typeQualifiers	*typeBase*/
+			/*yy:example int *p; */
+/*yy:case TypeQual   */ Pointer:
+				'*' TypeQualifiers
+			/*yy:example int **p; */
+/*yy:case Ptr        */ |	'*' TypeQualifiers Pointer
+			/*yy:example int atexit_b(void (^ _Nonnull)(void)); */
+/*yy:case Block      */ |	'^' TypeQualifiers
+
+			/*yy:field	noStorageClass */
+			/*yy:example int * const i; */
+/*yy:case TypeQual   */ TypeQualifiers:
+				TypeQualifier
+			/*yy:example int * __attribute__((a)) i; */
+/*yy:case Attribute  */ |	AttributeSpecifier
+			/*yy:example int * const volatile i; */
+			|	TypeQualifiers TypeQualifier
+			/*yy:example int * __attribute__((a)) __attribute__((b)) i; */
+			|	TypeQualifiers AttributeSpecifier
+
+			/*yy:example int f(int i) {} */
+/*yy:case List       */ ParameterTypeList:
+				ParameterList
+			/*yy:example int f(int i, ...) {} */
+/*yy:case Var        */ |	ParameterList ',' "..."
+
+			/*yy:example int f(int i) {} */
+			ParameterList:
+				ParameterDeclaration
+			/*yy:example int f(int i, int j) {} */
+			|	ParameterList ',' ParameterDeclaration
+
+			/*yy:field	typ	Type	*/
+			/*yy:example int f(int i) {} */
+/*yy:case Decl       */ ParameterDeclaration:
+				DeclarationSpecifiers Declarator AttributeSpecifierList
+			/*yy:example int f(int*) {} */
+/*yy:case Abstract   */ |	DeclarationSpecifiers AbstractDeclarator
+
+			/*yy:field	lexicalScope	Scope	*/
+			/*yy:example int f(i) int i; {}*/
+			IdentifierList:
+				IDENTIFIER
+			/*yy:example int f(i, j) int i, j; {}*/
+			|	IdentifierList ',' IDENTIFIER
+
+			/* [0], 6.7.6 Type names */
+			/*yy:field	typ	Type	*/
+			/*yy:example int i = (int)x; */
+			TypeName:
+				SpecifierQualifierList AbstractDeclarator
+
+			/*yy:field	typ	Type	*/
+			/*yy:example void f(int*); */
+/*yy:case Ptr        */ AbstractDeclarator:
+				Pointer
+			/*yy:example void f(int()); */
+/*yy:case Decl       */ |	Pointer DirectAbstractDeclarator
+
+			/*yy:field	paramScope	Scope */
+			/*yy:field	typeQualifiers	*typeBase */
+			/*yy:example void f(int()); */
+/*yy:case Decl       */ DirectAbstractDeclarator:
+				'(' AbstractDeclarator ')'
+			/*yy:example void f(int[const 42]); */
+/*yy:case Arr        */ |	DirectAbstractDeclarator '[' TypeQualifiers AssignmentExpression ']'
+			/*yy:example void f(int[static const 42]); */
+/*yy:case StaticArr  */ |	DirectAbstractDeclarator '[' "static" TypeQualifiers AssignmentExpression ']'
+			/*yy:example void f(int[const static 42]); */
+/*yy:case ArrStatic  */ |	DirectAbstractDeclarator '[' TypeQualifiers "static" AssignmentExpression ']'
+			/*yy:example void f(int[*]); */
+/*yy:case ArrStar    */ |	DirectAbstractDeclarator '[' '*' ']'
+			/*yy:example void f(int(char)); */
+/*yy:case Func       */ |	DirectAbstractDeclarator '(' ParameterTypeList ')'
+
+			/* [0], 6.7.8 Initialization */
+			/*yy:field	Field		Field   // Where aplicable	*/
+			/*yy:field	Offset		uintptr // Case Expr		*/
+			/*yy:field	field0		Field   			*/
+			/*yy:field	list		[]*Initializer			*/
+			/*yy:field	parent		*Initializer			*/
+			/*yy:field	trailingComma	*Token				*/
+			/*yy:field	typ	Type					*/
+			/*yy:field	isConst	bool					*/
+			/*yy:field	isZero	bool					*/
+			/*yy:example int i = x; */
+/*yy:case Expr       */ Initializer:
+				AssignmentExpression
+			/*yy:example int i[] = { x }; */
+/*yy:case InitList   */ |	'{' InitializerList ',' '}'
+
+			/*yy:field	list	[]*Initializer */
+			/*yy:field	isConst	bool */
+			/*yy:field	isZero	bool                 */
+			/*yy:example int i[] = { [10] = x }; */
+			InitializerList:
+				Designation Initializer
+			/*yy:example int i[] = { [10] = x, [20] = y }; */
+			|	InitializerList ',' Designation Initializer
+
+			/*yy:example int a[] = { [42] = 314 }; */
+			Designation:
+				DesignatorList '='
+
+			/*yy:example int a[] = { [42] = 314 }; */
+			DesignatorList:
+				Designator
+			/*yy:example int a[100][] = { [42][12] = 314 }; */
+			|	DesignatorList Designator
+
+			/*yy:field	lexicalScope	Scope	*/
+			/*yy:example int a[] = { [42] = 314 }; */
+/*yy:case Index      */ Designator:
+				'[' ConstantExpression ']'
+			/*yy:example struct t s = { .fld = 314 }; */
+/*yy:case Field      */ |	'.' IDENTIFIER
+			/*yy:example struct t s = { fld: 314 }; */
+/*yy:case Field2     */ |	IDENTIFIER ':'
+
+			/* [0], 6.8 Statements and blocks */
+			/*yy:field	Operand		Operand	// Case CompoundStatement, ExpressionStatement*/
+			/*yy:example int f() { L: x(); }*/
+/*yy:case Labeled    */ Statement:
+				LabeledStatement
+			/*yy:example int f() { { y(); } }*/
+/*yy:case Compound   */ |	CompoundStatement
+			/*yy:example int f() { x(); }*/
+/*yy:case Expr       */ |	ExpressionStatement
+			/*yy:example int f() { if(x) y(); }*/
+/*yy:case Selection  */ |	SelectionStatement
+			/*yy:example int f() { for(;;) x(); }*/
+/*yy:case Iteration  */ |	IterationStatement
+			/*yy:example int f() { return x; }*/
+/*yy:case Jump       */ |	JumpStatement
+			/*yy:example int f() { __asm__("nop"); }*/
+/*yy:case Asm        */ |	AsmStatement
+
+			/* [0], 6.8.1 Labeled statements */
+			/*yy:field	block		*CompoundStatement	*/
+			/*yy:field	lexicalScope	Scope			*/
+			/*yy:example int f() { L: goto L; } */
+/*yy:case Label      */ LabeledStatement:
+				IDENTIFIER ':' AttributeSpecifierList Statement
+			/*yy:example int f() { switch(i) case 42: x(); } */
+/*yy:case CaseLabel  */ |	"case" ConstantExpression ':' Statement
+			/*yy:example int f() { switch(i) case 42 ... 56: x(); } */
+/*yy:case Range      */ |	"case" ConstantExpression "..." ConstantExpression ':' Statement
+			/*yy:example int f() { switch(i) default: x(); } */
+/*yy:case Default    */ |	"default" ':' Statement
+
+			/* [0], 6.8.2 Compound statement */
+			/*yy:field	Operand		Operand			*/
+			/*yy:field	children	[]*CompoundStatement	*/
+			/*yy:field	declarations	[]*Declaration		*/
+			/*yy:field	isJumpTarget	bool			*/
+			/*yy:field	labeledStmts	[]*LabeledStatement	*/
+			/*yy:field	parent		*CompoundStatement	*/
+			/*yy:field	scope		Scope			*/
+			/*yy:example int f() { int i; } 		*/
+			CompoundStatement:
+				'{' BlockItemList '}'
+
+			/*yy:example int f() { int i; }*/
+			BlockItemList:
+				BlockItem
+			/*yy:example int f() { int i; double j; }*/
+			|	BlockItemList BlockItem
+
+			/*yy:field	fn *FunctionDefinition		// Case FuncDef */
+			/*yy:field	closure map[StringID]struct{}	// Case FuncDef */
+			/*yy:field	Last	bool	*/
+			/*yy:example int f() { int i; }*/
+/*yy:case Decl       */ BlockItem:
+				Declaration
+			/*yy:example int f() { g(); }*/
+/*yy:case Stmt       */ |	Statement
+			/*yy:example int f() { __label__ L; }*/
+/*yy:case Label      */ |	LabelDeclaration
+			/*yy:example int f() { int g() {} }*/
+/*yy:case FuncDef    */ |	DeclarationSpecifiers Declarator CompoundStatement
+			/*yy:example int f() {\n#pragma STDC FENV_ACCESS OFF\n}*/
+/*yy:case Pragma     */ |	PragmaSTDC
+
+			/* [0], 6.8.3 Expression and null statements */
+			/*yy:example int f() { g(); }*/
+			ExpressionStatement:
+				Expression AttributeSpecifierList ';'
+
+			/* [0], 6.8.4 Selection statements */
+			/*yy:field	promote		Type	// switch expression promoted type */
+			/*yy:field	cases	[]*LabeledStatement	*/
+			/*yy:example int f() { if(x) y(); } */
+/*yy:case If         */ SelectionStatement:
+				"if" '(' Expression ')' Statement %prec BELOW_ELSE
+			/*yy:example int f() { if(x) y(); else z(); } */
+/*yy:case IfElse     */ |	"if" '(' Expression ')' Statement "else" Statement
+			/*yy:example int f() { switch(i) case 42: x(); } */
+/*yy:case Switch     */ |	"switch" '(' Expression ')' Statement
+
+			/* [0], 6.8.5 Iteration statements */
+			/*yy:example int f() { while(x) y(); } */
+/*yy:case While      */ IterationStatement:
+				"while" '(' Expression ')' Statement
+			/*yy:example int f() { do x(); while(y); } */
+/*yy:case Do         */ |	"do" Statement "while" '(' Expression ')' ';'
+			/*yy:example int f() { for( i = 0; i < 10; i++) x(); } */
+/*yy:case For        */ |	"for" '(' Expression ';' Expression ';' Expression ')' Statement
+			/*yy:example int f() { for( int i = 0; i < 10; i++) x(); } */
+/*yy:case ForDecl    */ |	"for" '(' Declaration Expression ';' Expression ')' Statement
+
+			/* [0], 6.8.6 Jump statements */
+			/*yy:field	context		Node	*/
+			/*yy:field	lexicalScope	Scope	*/
+			/*yy:example int f() { L: goto L; } */
+/*yy:case Goto       */ JumpStatement:
+				"goto" IDENTIFIER ';'
+			/*yy:example int f() { L: x(); void *p = &&L; goto *p; } */
+/*yy:case GotoExpr   */ |	"goto" '*' Expression ';'
+			/*yy:example int f() { for(;;) if (i) continue; } */
+/*yy:case Continue   */ |	"continue" ';'
+			/*yy:example int f() { for(;;) if (i) break; } */
+/*yy:case Break      */ |	"break" ';'
+			/*yy:example int f() { if (i) return x; } */
+/*yy:case Return     */ |	"return" Expression ';'
+
+			/* [0], 6.9 External definitions */
+			/*yy:list*/
+			/*yy:example int i; */
+			TranslationUnit:
+				ExternalDeclaration
+			/*yy:example int i; int j; */
+			|	TranslationUnit ExternalDeclaration
+
+			/*yy:example int f() {} */
+/*yy:case FuncDef    */ ExternalDeclaration:
+				FunctionDefinition
+			/*yy:example int i; */
+/*yy:case Decl       */ |	Declaration
+			/*yy:example int f() __asm__("nop"); */
+/*yy:case Asm        */ |	AsmFunctionDefinition
+			/*yy:example __asm__("nop"); */
+/*yy:case AsmStmt    */ |	AsmStatement
+			/*yy:example ; */
+/*yy:case Empty      */ |	';'
+			/*yy:example #pragma STDC CX_LIMITED_RANGE DEFAULT */
+/*yy:case Pragma     */ |	PragmaSTDC
+
+			/* [0], 6.9.1 Function definitions */
+			/*yy:field	CallSiteComplexExpr	[]*AssignmentExpression		*/
+			/*yy:field	CompositeLiterals	[]*PostfixExpression		*/
+			/*yy:field	ComputedGotos		map[StringID]*UnaryExpression	*/
+			/*yy:field	Gotos			map[StringID]*JumpStatement	*/
+			/*yy:field	InitDeclarators		[]*InitDeclarator		*/
+			/*yy:field	Labels			map[StringID]*LabeledStatement	*/
+			/*yy:field	ReturnComplexExpr	[]*Expression			*/
+			/*yy:field	VLAs			[]*Declarator			*/
+			/*yy:field	compoundStatements	[]*CompoundStatement		*/
+			/*yy:field	checked			bool 				*/
+			/*yy:example int f() {} */
+			FunctionDefinition:
+				DeclarationSpecifiers Declarator DeclarationList CompoundStatement
+
+			/*yy:example int f(i) int i; {} */
+			DeclarationList:
+				Declaration
+			/*yy:example int f(i, j) int i; int j; {} */
+			|	DeclarationList Declaration
+
+			/* -------------------------------------- Extensions */
+
+			/*yy:example __asm__("nop": [a] b); */
+			AsmIndex:
+				'[' Expression ']'
+
+			/*yy:example __asm__("nop": a); */
+			AsmExpressionList:
+				AsmIndex AssignmentExpression
+			/*yy:example __asm__("nop": a, b); */
+			|	AsmExpressionList ',' AsmIndex AssignmentExpression
+
+			/*yy:example __asm__("nop": a); */
+			AsmArgList:
+				':' AsmExpressionList
+			/*yy:example __asm__("nop": a : b); */
+			|	AsmArgList ':' AsmExpressionList
+
+			/*yy:example __asm__("nop"); */
+			Asm:
+				"__asm__" AsmQualifierList '(' STRINGLITERAL AsmArgList ')'
+ 
+			/*yy:example void f() { __asm__("nop"); } */
+			AsmStatement:
+				Asm AttributeSpecifierList ';'
+
+			/*yy:example int f() __asm__("nop"); */
+			AsmFunctionDefinition:
+				DeclarationSpecifiers Declarator AsmStatement
+
+			/*yy:example __asm__ volatile ("nop"); */
+/*yy:case Volatile   */ AsmQualifier:
+				"volatile"
+			/*yy:example __asm__ inline ("nop"); */
+/*yy:case Inline     */ |	"inline"
+			/*yy:example __asm__ goto ("nop"); */
+/*yy:case Goto       */ |	"goto"
+
+			/*yy:example __asm__ inline ("nop"); */
+			AsmQualifierList:
+				AsmQualifier
+			/*yy:example __asm__ inline volatile ("nop"); */
+			|	AsmQualifierList AsmQualifier
+
+			/*yy:example int f() { __label__ L; L: x(); } */
+			LabelDeclaration:
+				"__label__" IdentifierList ';'
+
+			/* [4], 6.37 Attribute Syntax */
+			/*yy:example int i __attribute__((a(b))); */
+			ExpressionList:
+				AssignmentExpression
+			/*yy:example int i __attribute__((a(b, c))); */
+			|	ExpressionList ',' AssignmentExpression
+
+			/*yy:field	lexicalScope	Scope	*/
+			/*yy:example int i __attribute__((a)); */
+/*yy:case Ident      */ AttributeValue:
+				IDENTIFIER
+			/*yy:example int i __attribute__((a(b))); */
+/*yy:case Expr       */ |	IDENTIFIER '(' ExpressionList ')'
+
+			/*yy:example int i __attribute__((a)); */
+			AttributeValueList:
+				AttributeValue
+			/*yy:example int i __attribute__((a, b)); */
+			|	AttributeValueList ',' AttributeValue
+
+			/*yy:example int i __attribute__((a)); */
+			AttributeSpecifier:
+				"__attribute__" '(' '(' AttributeValueList ')' ')'
+
+			/*yy:example int i __attribute__((a)); */
+			AttributeSpecifierList:
+				AttributeSpecifier %prec BELOW_ATTRIBUTE
+			/*yy:example int i __attribute__((a)) __attribute((b)); */
+			|	AttributeSpecifierList AttributeSpecifier
+
+			/*yy:example _Pragma("STDC FP_CONTRACT ON") */
+			PragmaSTDC:
+				"__pragma_stdc" IDENTIFIER IDENTIFIER IDENTIFIER