Merge pull request #1233 from andrew-johnson-4/ansi-c-frontend-qfqepr

Ansi c frontend qfqepr

PLUGINS/FRONTEND/C/c-grammar.ebnf

@@ -0,0 +1,279 @@
+(* c99-grammar.txt --- C99 grammar in ISO EBNF notation by katahiromz *)
+(* Version 0.0 *)
+(* Copyright (C) 2017 Katayama Hirofumi MZ. License: MIT *)
+(* See also http://www.quut.com/c/ANSI-C-grammar-y-2011.html *)
+
+translation-unit = {external-declaration};
+
+external-declaration = function-definition
+                     | declaration;
+
+function-definition = declaration-specifiers, declarator, [declaration-list], compound-statement;
+
+declaration = declaration-specifiers, [init-declarator-list], ';'
+            | static-assert-declaration
+            | ';';
+
+declaration-specifiers = declaration-specifier, {declaration-specifier};
+
+declaration-specifier = storage-class-specifier
+                      | type-specifier
+                      | type-qualifier
+                      | function-specifier
+                      | alignment-specifier;
+
+declarator = [pointer], direct-declarator;
+
+declaration-list = declaration, {declaration};
+
+compound-statement = '{', {declaration-or-statement}, '}';
+
+declaration-or-statement = declaration | statement;
+
+init-declarator-list = init-declarator, {',', init-declarator};
+
+init-declarator = declarator, ['=', initializer];
+
+static-assert-declaration = '_Static_assert', '(', constant-expression, ',', string-literal, ')', ';';
+
+storage-class-specifier = 'typedef'
+                        | 'extern'
+                        | 'static'
+                        | '_Thread_local'
+                        | 'auto'
+                        | 'register';
+
+type-specifier = 'void'
+               | 'char'
+               | 'short'
+               | 'int'
+               | 'long'
+               | 'float'
+               | 'double'
+               | 'signed'
+               | 'unsigned'
+               | '_Bool'
+               | '_Complex'
+               | '_Imaginary'       (* non-mandated extension *)
+               | atomic-type-specifier
+               | struct-or-union-specifier
+               | enum-specifier
+               | typedef-name;
+
+(* NOTE: Please define typedef-name as result of 'typedef'. *)
+typedef-name = identifier;
+
+type-qualifier = 'const'
+               | 'restrict'
+               | 'volatile'
+               | '_Atomic';
+
+function-specifier = 'inline'
+                   | '_Noreturn';
+
+alignment-specifier = '_Alignas', '(', type-name, ')'
+                    | '_Alignas', '(', constant-expression, ')';
+
+pointer = '*', [type-qualifier-list], [pointer];
+
+direct-declarator = identifier
+                  | '(', declarator, ')'
+                  | direct-declarator, '[', ['*'], ']'
+                  | direct-declarator, '[', 'static', [type-qualifier-list], assignment-expression, ']'
+                  | direct-declarator, '[', type-qualifier-list, ['*'], ']'
+                  | direct-declarator, '[', type-qualifier-list, ['static'], assignment-expression, ']'
+                  | direct-declarator, '[', assignment-expression, ']'
+                  | direct-declarator, '(', parameter-type-list, ')'
+                  | direct-declarator, '(', identifier-list, ')'
+                  | direct-declarator, '(', ')';
+
+identifier-list = identifier, {',', identifier};
+
+initializer-list = designative-initializer, {',', designative-initializer};
+
+designative-initializer = [designation], initializer;
+
+initializer = '{', initializer-list, [','], '}'
+            | assignment-expression;
+
+constant-expression = conditional-expression;  (* with constraints *)
+
+atomic-type-specifier = '_Atomic', '(', type-name, ')';
+
+struct-or-union-specifier = struct-or-union, '{', struct-declaration-list, '}'
+                          | struct-or-union, identifier, ['{', struct-declaration-list, '}'];
+
+struct-or-union = 'struct'
+                | 'union';
+
+struct-declaration-list = struct-declaration, {struct-declaration};
+
+struct-declaration = specifier-qualifier-list, ';'     (* for anonymous struct/union *)
+                   | specifier-qualifier-list, struct-declarator-list, ';'
+                   | static-assert-declaration;
+
+enum-specifier = 'enum', '{', enumerator-list, [','], '}'
+               | 'enum', identifier, ['{', enumerator-list, [','], '}'];
+
+enumerator-list = enumerator, {',', enumerator};
+
+(* NOTE: Please define enumeration-constant for identifier inside enum { ... }. *)
+enumerator = enumeration-constant, ['=', constant-expression];
+
+enumeration-constant = identifier;
+
+type-name = specifier-qualifier-list, [abstract-declarator];
+
+specifier-qualifier-list = specifier-qualifier, {specifier-qualifier};
+
+specifier-qualifier = type-specifier | type-qualifier;
+
+abstract-declarator = pointer, [direct-abstract-declarator]
+                    | direct-abstract-declarator;
+
+direct-abstract-declarator = '(', abstract-declarator, ')'
+                           | '(', parameter-type-list, ')'
+                           | '(', ')'
+                           | '[', ['*'], ']'
+                           | '[', 'static', [type-qualifier-list], assignment-expression, ']'
+                           | '[', type-qualifier-list, [['static'], assignment-expression], ']'
+                           | '[', assignment-expression, ']'
+                           | direct-abstract-declarator, '[', ['*'], ']'
+                           | direct-abstract-declarator, '[', 'static', [type-qualifier-list], assignment-expression, ']'
+                           | direct-abstract-declarator, '[', type-qualifier-list, [['static'], assignment-expression], ']'
+                           | direct-abstract-declarator, '[', assignment-expression, ']'
+                           | direct-abstract-declarator, '(', parameter-type-list, ')'
+                           | direct-abstract-declarator, '(', ')';
+
+struct-declarator-list = struct-declarator, {',', struct-declarator};
+
+type-qualifier-list = type-qualifier, {type-qualifier};
+
+parameter-type-list = parameter-list, [',', '...'];
+
+struct-declarator = ':', constant-expression
+                  | declarator, [':', constant-expression];
+
+assignment-operator = '=' 
+                    | '*=' 
+                    | '/=' 
+                    | '%=' 
+                    | '+=' 
+                    | '-=' 
+                    | '<<=' 
+                    | '>>=' 
+                    | '&=' 
+                    | '^=' 
+                    | '|=';
+
+parameter-list = parameter-declaration, {',', parameter-declaration};
+
+parameter-declaration = declaration-specifiers, [declarator | abstract-declarator];
+
+expression = assignment-expression, {',', assignment-expression};
+
+assignment-expression = conditional-expression
+                      | unary-expression, assignment-operator, assignment-expression;
+
+conditional-expression = logical-or-expression, ['?', expression, ':', conditional-expression];
+
+logical-or-expression = logical-and-expression, {'||', logical-and-expression};
+
+logical-and-expression = inclusive-or-expression, {'&&', inclusive-or-expression};
+
+inclusive-or-expression = exclusive-or-expression, {'|', exclusive-or-expression};
+
+exclusive-or-expression = and-expression, {'^', and-expression};
+
+and-expression = equality-expression, {'&', equality-expression};
+
+equality-expression = relational-expression, {('==' | '!='), relational-expression};
+
+relational-expression = shift-expression, {('<' | '>' | '<=' | '>='), shift-expression};
+
+shift-expression = additive-expression, {('<<' | '>>'), additive-expression};
+
+additive-expression = multiplicative-expression, {('+' | '-'), multiplicative-expression};
+
+multiplicative-expression = cast-expression, {('*' | '/' | '%'), cast-expression};
+
+cast-expression = unary-expression
+                | '(', type-name, ')', cast-expression;
+
+unary-expression = postfix-expression
+                 | ('++' | '--'), unary-expression
+                 | unary-operator, cast-expression
+                 | 'sizeof', unary-expression
+                 | 'sizeof', '(', type-name, ')'
+                 | '_Alignof', '(', type-name, ')';
+
+postfix-expression = primary-expression
+                   | postfix-expression, '[', expression, ']'
+                   | postfix-expression, '(', [argument-expression-list], ')'
+                   | postfix-expression, ('.' | '->'), identifier
+                   | postfix-expression, ('++' | '--')
+                   | '(', type-name, ')', '{', initializer-list, [','], '}';
+
+unary-operator = '&'
+               | '*'
+               | '+'
+               | '-'
+               | '~'
+               | '!';
+
+primary-expression = identifier
+                   | constant
+                   | string
+                   | '(', expression, ')'
+                   | generic-selection;
+
+argument-expression-list = assignment-expression, {',', assignment-expression};
+
+constant = integer-constant
+         | character-constant
+         | floating-constant
+         | enumeration-constant;
+
+string = string-literal
+       | '__func__';
+
+generic-selection = '_Generic', '(', assignment-expression, ',', generic-assoc-list, ')';
+
+generic-assoc-list = generic-association, {',', generic-association};
+
+generic-association = type-name, ':', assignment-expression
+                    | 'default', ':', assignment-expression;
+
+designation = designator-list, '=';
+
+designator-list = designator, {designator};
+
+designator = '[', constant-expression, ']'
+           | '.', identifier;
+
+statement = labeled-statement
+          | compound-statement
+          | expression-statement
+          | selection-statement
+          | iteration-statement
+          | jump-statement;
+
+labeled-statement = identifier, ':', statement
+                  | 'case', constant-expression, ':', statement
+                  | 'default', ':', statement;
+
+expression-statement = [expression], ';';
+
+selection-statement = 'if', '(', expression, ')', statement, 'else', statement
+                    | 'if', '(', expression, ')', statement
+                    | 'switch', '(', expression, ')', statement;
+
+ iteration-statement = 'while', '(', expression, ')', statement
+                     | 'do', statement, 'while', '(', expression, ')', ';'
+                     | 'for', '(', [expression], ';', [expression], ';', [expression], ')', statement
+                     | 'for', '(', declaration, [expression], ';', [expression], ')', statement;
+
+jump-statement = 'goto', identifier, ';'
+               | 'continue', ';'
+               | 'break', ';'
+               | 'return', [expression], ';';