Mirrors/gotosocial
1
0
Fork 0
mirror of https://github.com/superseriousbusiness/gotosocial.git synced 2024-11-01 06:50:00 +00:00
Code Issues Projects Releases Packages Wiki Activity
gotosocial/vendor/modernc.org/cc/v3/parser.yy
tobi 07727753b9
[feature] Clean up/uncache remote media (#407) 
* Add whereNotEmptyAndNotNull

* Add GetRemoteOlderThanDays

* Add GetRemoteOlderThanDays

* Add PruneRemote to Manager interface

* Start implementing PruneRemote

* add new attachment + status to tests

* fix up and test GetRemoteOlderThan

* fix bad import

* PruneRemote: return number pruned

* add Cached column to mediaattachment

* update + test pruneRemote

* update mediaTest

* use Cached column

* upstep bun to latest version

* embed structs in mediaAttachment

* migrate mediaAttachment to new format

* don't default cached to true

* select only remote media

* update db dependencies

* step bun back to last working version

* update pruneRemote to use Cached field

* fix storage path of test attachments

* add recache logic to manager

* fix trimmed aspect ratio

* test prune and recache

* return errwithcode

* tidy up different paths for emoji vs attachment

* fix incorrect thumbnail type being stored

* expose TransportController to media processor

* implement tee-ing recached content

* add thoughts of dog to test fedi attachments

* test get remote files

* add comment on PruneRemote

* add postData cleanup to recache

* test thumbnail fetching

* add incredible diagram

* go mod tidy

* buffer pipes for recache streaming

* test for client stops reading after 1kb

* add media-remote-cache-days to config

* add cron package

* wrap logrus so it's available to cron

* start and stop cron jobs gracefully
2022-03-07 11:08:26 +01:00

1034 lines
35 KiB
Text
Raw Blame History

%{
// 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
Reference in a new issue View git blame Copy permalink