From 8e9394ad85bc921e0658fd2758f5717540101627 Mon Sep 17 00:00:00 2001 From: Melody Horn Date: Mon, 19 Oct 2020 17:53:49 -0600 Subject: explicitly target C --- index.md | 82 +++++++- syntax.md | 696 +++++++++++++++++++++++++++++++------------------------------- 2 files changed, 421 insertions(+), 357 deletions(-) diff --git a/index.md b/index.md index 72e2572..55d1646 100644 --- a/index.md +++ b/index.md @@ -1,25 +1,87 @@ Crowbar: the good parts of C, with a little bit extra. -This is entirely a work-in-progress, and should not be relied upon to be stable in any way. +**This is entirely a work-in-progress, and should not be relied upon to be stable in any way.** -# Context +Crowbar is a language that compiles directly to [C99](https://en.wikipedia.org/wiki/C99), and aims to remove as many [footgun](https://en.wiktionary.org/wiki/footgun)s and as much needless complexity from C as possible while still being familiar to C developers. -- [Rust is not a good C replacement](https://drewdevault.com/2019/03/25/Rust-is-not-a-good-C-replacement.html) +Ideally, a typical C codebase should be straightforward to rewrite in Crowbar, and any atypical C constructions not supported by Crowbar can be left as C. -# cactus's Blog Posts +In principle, there's no reason it would be impossible to write a compiler directly for Crowbar, skipping the C step entirely, but that would take a lot of work. -- [Crowbar: Defining a good C replacement](https://www.boringcactus.com/2020/09/28/crowbar-1-defining-a-c-replacement.html) -- [Crowbar: Simplifying C's type names](https://www.boringcactus.com/2020/10/13/crowbar-2-simplifying-c-type-names.html) +# Removals + +Some of the footguns and complexity in C come from misfeatures that can simply not be used. + +## Footguns + +### Almost Always The Wrong Thing + +- `goto` +- Octal literals +- Hexadecimal float literals +- Wide characters +- Digraphs +- Prefix `++` and `--` +- Chaining mixed left and right shifts (e.g. `x << 3 >> 2`) +- Chaining relational/equality operators (e.g. `3 < x == 2`) +- Mixed chains of bitwise or logical operators (e.g. `2 & x && 4 ^ y`) +- The comma operator `,` +- Strings that aren't UTF-8 + +### Explicit Beats Implicit + +- `typedef` +- Octal escape sequences +- Using an assignment operator (`=`, `+=`, etc) or (postfix) `++` and `--` as components in a larger expression +- The conditional operator `?:` +- Preprocessor macros (but constants are fine) + +## Needless Complexity + +### Let The Compiler Decide + +- `inline` +- `register` + +### Who Even Cares + +- `restrict` +- `volatile` +- `_Imaginary` -# Additions to C +# Adjustments -For Crowbar to be "the good parts of C, with a little bit extra", we must first decide what C lacks. -C has several widely known footguns, some of which are misfeatures that can simply be not supported, but some of which are insecure-by-default. -As such, new features must be added to engage the safeties on these proverbial footguns. +Some C features are footguns by default, so Crowbar ensures that they are only used correctly. + +- Unions blah blah blah + +C's syntax isn't perfect, but it's usually pretty good. +However, sometimes it just sucks, and in those cases Crowbar makes changes. + +- Complicated types (function pointers, pointer-to-`const` vs `const`-pointer, etc) +- `_Bool` is just `bool`, `_Complex` is just `complex` (why drag the preprocessor into it?) +- Adding a `_` to numeric literals as a separator + +# Additions + +## Anti-Footguns - C is generous with memory in ways that are unreliable by default. Crowbar adds [memory safety guarantees](safety.md) to make correctness the default behavior. +## Trivial Room For Improvement + +- Binary literals, prefixed with `0b`/`0B` + +# Context + +- [Rust is not a good C replacement](https://drewdevault.com/2019/03/25/Rust-is-not-a-good-C-replacement.html) + +# cactus's Blog Posts + +- [Crowbar: Defining a good C replacement](https://www.boringcactus.com/2020/09/28/crowbar-1-defining-a-c-replacement.html) +- [Crowbar: Simplifying C's type names](https://www.boringcactus.com/2020/10/13/crowbar-2-simplifying-c-type-names.html) + # Syntax [Read the Syntax chapter of the spec.](syntax.md) diff --git a/syntax.md b/syntax.md index b4d0dc8..3196dfe 100644 --- a/syntax.md +++ b/syntax.md @@ -1,347 +1,349 @@ -The syntax of Crowbar will eventually mostly match the syntax of C, with fewer obscure/advanced/edge case features. - -# Source Files - -A Crowbar source file is UTF-8. -Crowbar source files can come in two varieties, an *implementation file* and a *header file*. -An implementation file conventionally has a `.cro` extension, and a header file conventionally has a `.hro` extension. - -A Crowbar source file is read into memory in two phases: *scanning* (which converts text into an unstructured sequence of tokens) and *parsing* (which converts an unstructured sequence of tokens into a parse tree). - -# Scanning - -A *token* is one of the following kinds of token: -- a *keyword*, -- an *identifier*, -- a *constant*, -- a *string literal*, -- or a *punctuator*. - -Tokens are separated by either *whitespace* or a *comment*. - -## Keywords - -A *keyword* is one of the following literal words: -- `bool` -- `break` -- `case` -- `char` -- `const` -- `continue` -- `default` -- `do` -- `double` -- `else` -- `enum` -- `extern` -- `float` -- `for` -- `function` -- `if` -- `include` -- `int` -- `long` -- `return` -- `short` -- `signed` -- `sizeof` -- `struct` -- `switch` -- `typedef` -- `unsigned` -- `void` -- `while` - -## Identifiers - -An *identifier* is a sequence of one or more characters having Unicode categories within a legal set. - -The first character in an identifier must have one of the following Unicode categories: -- Connector Punctuation (e.g. `_`) -- Format Other (e.g. Zero-Width Joiner) -- Lowercase Letter (e.g. `h`) -- Modifier Letter (e.g. `ʹ`, U+02B9 Modifier Letter Prime) -- Modifier Symbol (e.g. `^`, U+005E Circumflex Accent) -- Nonspacing Mark (e.g. ` ̂`, U+0302 Combining Circumflex Accent) -- Other Letter (e.g. `א`, U+05D0 Hebrew Letter Alef) -- Titlecase Letter (e.g. `Dž`, U+01C5 Latin Capital Letter D With Small Letter Z With Caron) -- Uppercase Letter (e.g. `B`) - -Subsequent characters may have any of the above-listed Unicode categories, or one of the following: -- Decimal Digit Number (e.g. `0`) -- Letter Number (e.g. `Ⅳ`, U+2163 Roman Numeral Four) -- Other Number (e.g. `¼`, U+00BC Vulgar Fraction One Quarter) - -## Constants - -A *constant* can have one of five types: -- a *decimal constant*, a sequence of characters drawn from the set {`0`, `1`, `2`, `3`, `4`, `5`, `6`, `7`, `8`, `9`, `_`}; -- a *binary constant*, a prefix (either `0b` or `0B`) followed by a sequence of characters drawn from the set {`0`, `1`, `_`}; -- a *hexadecimal constant*, a prefix (either `0x` or `0X`) followed by a sequence of characters drawn from the set {`0`, `1`, `2`, `3`, `4`, `5`, `6`, `7`, `8`, `9`, `A`, `a`, `B`, `b`, `C`, `c`, `D`, `d`, `E`, `e`, `F`, `f`, `_`}; -- a *floating-point constant*, a decimal constant followed by one of - - `.` followed by a decimal constant, - - either `e` or `E` followed by a decimal constant, - - or a `.` followed by a decimal constant followed by either an `e` or `E` followed by a decimal constant; -- or a *character constant*, a `'` followed by either a single character or an *escape sequence* followed by another `'`. - -### Escape Sequences - -The following sequences of characters are *escape sequences*: -- `\'` -- `\"` -- `\\` -- `\r` -- `\n` -- `\t` -- `\0` -- `\x` followed by two characters drawn from the set {`0`, `1`, `2`, `3`, `4`, `5`, `6`, `7`, `8`, `9`, `A`, `a`, `B`, `b`, `C`, `c`, `D`, `d`, `E`, `e`, `F`, `f`} -- `\u` followed by four characters drawn from the set {`0`, `1`, `2`, `3`, `4`, `5`, `6`, `7`, `8`, `9`, `A`, `a`, `B`, `b`, `C`, `c`, `D`, `d`, `E`, `e`, `F`, `f`} -- `\U` followed by eight characters drawn from the set {`0`, `1`, `2`, `3`, `4`, `5`, `6`, `7`, `8`, `9`, `A`, `a`, `B`, `b`, `C`, `c`, `D`, `d`, `E`, `e`, `F`, `f`} - -## String Literals - -A *string literal* begins with a `"`. -It then contains a sequence where each element is either an escape sequence or a character that is neither `"` nor `\`. -It then ends with a `"`. - -## Punctuators - -The following sequences of characters form *punctuators*: -- `[` -- `]` -- `(` -- `)` -- `{` -- `}` -- `.` -- `,` -- `+` -- `-` -- `*` -- `/` -- `%` -- `;` -- `!` -- `&` -- `|` -- `^` -- the tilde, `~` (given special treatment on this line due to [a bug in the Markdown renderer that sr.ht uses](https://github.com/miyuchina/mistletoe/issues/91)) -- `>` -- `<` -- `=` -- `->` -- `++` -- `--` -- `>>` -- `<<` -- `<=` -- `>=` -- `==` -- `!=` -- `&&` -- `||` -- `+=` -- `-=` -- `*=` -- `/=` -- `%=` -- `&=` -- `|=` -- `^=` - -## Whitespace - -A nonempty sequence of characters is considered to be *whitespace* if each character in it has a Unicode class of either Space Separator or Control Other. - -## Comments - -A *comment* can be either a *line comment* or a *block comment*. - -A *line comment* begins with the characters `//` if they occur outside of a string literal or comment, and ends with a newline character U+000A. - -A *block comment* begins with the characters `/*` if they occur outside of a string literal or comment, and ends with the characters `*/`. - -# Parsing - -The syntax of Crowbar is given as a [parsing expression grammar](https://en.wikipedia.org/wiki/Parsing_expression_grammar): - -## Entry points - -``` -HeaderFile ← HeaderFileElement+ -HeaderFileElement ← IncludeStatement / - TypeDeclaration / - FunctionDeclaration - -ImplementationFile ← ImplementationFileElement+ -ImplementationFileElement ← HeaderFileElement / - FunctionDefinition -``` - -## Top-level elements - -``` -IncludeStatement ← 'include' string-literal ';' - -TypeDeclaration ← StructDeclaration / - EnumDeclaration / - TypedefDeclaration -StructDeclaration ← 'struct' identifier '{' VariableDeclaration+ '}' ';' -EnumDeclaration ← 'enum' identifier '{' EnumBody '}' ';' -EnumBody ← identifier ('=' Expression)? ',' EnumBody / - identifier ('=' Expression)? ','? -TypedefDeclaration ← 'typedef' identifier '=' Type ';' - -FunctionDeclaration ← FunctionSignature ';' -FunctionDefinition ← FunctionSignature Block -FunctionSignature ← Type identifier '(' SignatureArguments? ')' -SignatureArguments ← Type identifier ',' SignatureArguments / - Type identifier ','? -``` - -## Statements - -``` -Block ← '{' Statement* '}' - -Statement ← VariableDefinition / - VariableDeclaration / - IfStatement / - SwitchStatement / - WhileStatement / - DoWhileStatement / - ForStatement / - FlowControlStatement / - AssignmentStatement / - ExpressionStatement - -VariableDefinition ← Type identifier '=' Expression ';' -VariableDeclaration ← Type identifier ';' - -IfStatement ← 'if' Expression Block 'else' Block / - 'if' Expression Block - -SwitchStatement ← 'switch' Expression '{' SwitchCase+ '}' -SwitchCase ← CaseSpecifier Block / - 'default' Block -CaseSpecifier ← 'case' Expression ',' CaseSpecifier / - 'case' Expression ','? - -WhileStatement ← 'while' Expression Block -DoWhileStatement ← 'do' Block 'while' Expression ';' -ForStatement ← 'for' VariableDefinition? ';' Expression ';' AssignmentStatementBody? Block - -FlowControlStatement ← 'continue' ';' / - 'break' ';' / - 'return' Expression? ';' - -AssignmentStatement ← AssignmentStatementBody ';' -AssignmentStatementBody ← AssignmentTargetExpression '=' Expression / - AssignmentTargetExpression '+=' Expression / - AssignmentTargetExpression '-=' Expression / - AssignmentTargetExpression '*=' Expression / - AssignmentTargetExpression '/=' Expression / - AssignmentTargetExpression '%=' Expression / - AssignmentTargetExpression '&=' Expression / - AssignmentTargetExpression '^=' Expression / - AssignmentTargetExpression '|=' Expression / - AssignmentTargetExpression '++' / - AssignmentTargetExpression '--' - -ExpressionStatement ← Expression ';' -``` - -## Types - -``` -Type ← 'const' BasicType / - BasicType '*' / - BasicType '[' Expression ']' / - BasicType 'function' '(' (BasicType ',')* ')' / - BasicType -BasicType ← 'void' / - IntegerType / - 'signed' IntegerType / - 'unsigned' IntegerType / - 'float' / - 'double' / - 'bool' / - 'struct' identifier / - 'enum' identifier / - 'typedef' identifier / - '(' Type ')' -IntegerType ← 'char' / - 'short' / - 'int' / - 'long' -``` - -## Expressions - -``` -AssignmentTargetExpression ← identifier ATEElementSuffix* -ATEElementSuffix ← '[' Expression ']' / - '.' identifier / - '->' identifier - -AtomicExpression ← identifier / - constant / - string-literal / - '(' Expression ')' - -ObjectExpression ← AtomicExpression ObjectSuffix* / - ArrayLiteralExpression / - StructLiteralExpression -ObjectSuffix ← '[' Expression ']' / - '(' CommasExpressionList? ')' / - '.' identifier / - '->' identifier -CommasExpressionList ← Expression ',' CommasExpressionList? / - Expression ','? -ArrayLiteralExpression ← '{' CommasExpressionList '}' -StructLiteralExpression ← '{' StructLiteralBody '}' -StructLiteralBody ← StructLiteralElement ',' StructLiteralBody? / - StructLiteralElement ','? -StructLiteralElement ← '.' identifier '=' Expression - -FactorExpression ← '(' Type ')' FactorExpression / - '&' FactorExpression / - '*' FactorExpression / - '+' FactorExpression / - '-' FactorExpression / - '~' FactorExpression / - '!' FactorExpression / - 'sizeof' FactorExpression / - 'sizeof' Type / - ObjectExpression - -TermExpression ← FactorExpression TermSuffix* -TermSuffix ← '*' FactorExpression / - '/' FactorExpression / - '%' FactorExpression - -ArithmeticExpression ← TermExpression ArithmeticSuffix* -ArithmeticSuffix ← '+' TermExpression / - '-' TermExpression - -BitwiseOpExpression ← ArithmeticExpression '<<' ArithmeticExpression / - ArithmeticExpression '>>' ArithmeticExpression / - ArithmeticExpression '^' ArithmeticExpression / - ArithmeticExpression ('&' ArithmeticExpression)+ / - ArithmeticExpression ('|' ArithmeticExpression)+ / - ArithmeticExpression - -ComparisonExpression ← BitwiseOpExpression '==' BitwiseOpExpression / - BitwiseOpExpression '!=' BitwiseOpExpression / - BitwiseOpExpression '<=' BitwiseOpExpression / - BitwiseOpExpression '>=' BitwiseOpExpression / - BitwiseOpExpression '<' BitwiseOpExpression / - BitwiseOpExpression '>' BitwiseOpExpression / - BitwiseOpExpression - -Expression ← ComparisonExpression ('&&' ComparisonExpression)+ / - ComparisonExpression ('||' ComparisonExpression)+ / - ComparisonExpression -``` - -[![Creative Commons BY-SA License](https://i.creativecommons.org/l/by-sa/4.0/80x15.png)](http://creativecommons.org/licenses/by-sa/4.0/) +The syntax of Crowbar will eventually mostly match the syntax of C, with fewer obscure/advanced/edge case features. + +**(either this is from before i settled on compile-to-C as the primary semantics and therefore it's very outdated, or i updated this and forgot to remove this warning)** + +# Source Files + +A Crowbar source file is UTF-8. +Crowbar source files can come in two varieties, an *implementation file* and a *header file*. +An implementation file conventionally has a `.cro` extension, and a header file conventionally has a `.hro` extension. + +A Crowbar source file is read into memory in two phases: *scanning* (which converts text into an unstructured sequence of tokens) and *parsing* (which converts an unstructured sequence of tokens into a parse tree). + +# Scanning + +A *token* is one of the following kinds of token: +- a *keyword*, +- an *identifier*, +- a *constant*, +- a *string literal*, +- or a *punctuator*. + +Tokens are separated by either *whitespace* or a *comment*. + +## Keywords + +A *keyword* is one of the following literal words: +- `bool` +- `break` +- `case` +- `char` +- `const` +- `continue` +- `default` +- `do` +- `double` +- `else` +- `enum` +- `extern` +- `float` +- `for` +- `function` +- `if` +- `include` +- `int` +- `long` +- `return` +- `short` +- `signed` +- `sizeof` +- `struct` +- `switch` +- `typedef` +- `unsigned` +- `void` +- `while` + +## Identifiers + +An *identifier* is a sequence of one or more characters having Unicode categories within a legal set. + +The first character in an identifier must have one of the following Unicode categories: +- Connector Punctuation (e.g. `_`) +- Format Other (e.g. Zero-Width Joiner) +- Lowercase Letter (e.g. `h`) +- Modifier Letter (e.g. `ʹ`, U+02B9 Modifier Letter Prime) +- Modifier Symbol (e.g. `^`, U+005E Circumflex Accent) +- Nonspacing Mark (e.g. ` ̂`, U+0302 Combining Circumflex Accent) +- Other Letter (e.g. `א`, U+05D0 Hebrew Letter Alef) +- Titlecase Letter (e.g. `Dž`, U+01C5 Latin Capital Letter D With Small Letter Z With Caron) +- Uppercase Letter (e.g. `B`) + +Subsequent characters may have any of the above-listed Unicode categories, or one of the following: +- Decimal Digit Number (e.g. `0`) +- Letter Number (e.g. `Ⅳ`, U+2163 Roman Numeral Four) +- Other Number (e.g. `¼`, U+00BC Vulgar Fraction One Quarter) + +## Constants + +A *constant* can have one of five types: +- a *decimal constant*, a sequence of characters drawn from the set {`0`, `1`, `2`, `3`, `4`, `5`, `6`, `7`, `8`, `9`, `_`}; +- a *binary constant*, a prefix (either `0b` or `0B`) followed by a sequence of characters drawn from the set {`0`, `1`, `_`}; +- a *hexadecimal constant*, a prefix (either `0x` or `0X`) followed by a sequence of characters drawn from the set {`0`, `1`, `2`, `3`, `4`, `5`, `6`, `7`, `8`, `9`, `A`, `a`, `B`, `b`, `C`, `c`, `D`, `d`, `E`, `e`, `F`, `f`, `_`}; +- a *floating-point constant*, a decimal constant followed by one of + - `.` followed by a decimal constant, + - either `e` or `E` followed by a decimal constant, + - or a `.` followed by a decimal constant followed by either an `e` or `E` followed by a decimal constant; +- or a *character constant*, a `'` followed by either a single character or an *escape sequence* followed by another `'`. + +### Escape Sequences + +The following sequences of characters are *escape sequences*: +- `\'` +- `\"` +- `\\` +- `\r` +- `\n` +- `\t` +- `\0` +- `\x` followed by two characters drawn from the set {`0`, `1`, `2`, `3`, `4`, `5`, `6`, `7`, `8`, `9`, `A`, `a`, `B`, `b`, `C`, `c`, `D`, `d`, `E`, `e`, `F`, `f`} +- `\u` followed by four characters drawn from the set {`0`, `1`, `2`, `3`, `4`, `5`, `6`, `7`, `8`, `9`, `A`, `a`, `B`, `b`, `C`, `c`, `D`, `d`, `E`, `e`, `F`, `f`} +- `\U` followed by eight characters drawn from the set {`0`, `1`, `2`, `3`, `4`, `5`, `6`, `7`, `8`, `9`, `A`, `a`, `B`, `b`, `C`, `c`, `D`, `d`, `E`, `e`, `F`, `f`} + +## String Literals + +A *string literal* begins with a `"`. +It then contains a sequence where each element is either an escape sequence or a character that is neither `"` nor `\`. +It then ends with a `"`. + +## Punctuators + +The following sequences of characters form *punctuators*: +- `[` +- `]` +- `(` +- `)` +- `{` +- `}` +- `.` +- `,` +- `+` +- `-` +- `*` +- `/` +- `%` +- `;` +- `!` +- `&` +- `|` +- `^` +- the tilde, `~` (given special treatment on this line due to [a bug in the Markdown renderer that sr.ht uses](https://github.com/miyuchina/mistletoe/issues/91)) +- `>` +- `<` +- `=` +- `->` +- `++` +- `--` +- `>>` +- `<<` +- `<=` +- `>=` +- `==` +- `!=` +- `&&` +- `||` +- `+=` +- `-=` +- `*=` +- `/=` +- `%=` +- `&=` +- `|=` +- `^=` + +## Whitespace + +A nonempty sequence of characters is considered to be *whitespace* if each character in it has a Unicode class of either Space Separator or Control Other. + +## Comments + +A *comment* can be either a *line comment* or a *block comment*. + +A *line comment* begins with the characters `//` if they occur outside of a string literal or comment, and ends with a newline character U+000A. + +A *block comment* begins with the characters `/*` if they occur outside of a string literal or comment, and ends with the characters `*/`. + +# Parsing + +The syntax of Crowbar is given as a [parsing expression grammar](https://en.wikipedia.org/wiki/Parsing_expression_grammar): + +## Entry points + +``` +HeaderFile ← HeaderFileElement+ +HeaderFileElement ← IncludeStatement / + TypeDeclaration / + FunctionDeclaration + +ImplementationFile ← ImplementationFileElement+ +ImplementationFileElement ← HeaderFileElement / + FunctionDefinition +``` + +## Top-level elements + +``` +IncludeStatement ← 'include' string-literal ';' + +TypeDeclaration ← StructDeclaration / + EnumDeclaration / + TypedefDeclaration +StructDeclaration ← 'struct' identifier '{' VariableDeclaration+ '}' ';' +EnumDeclaration ← 'enum' identifier '{' EnumBody '}' ';' +EnumBody ← identifier ('=' Expression)? ',' EnumBody / + identifier ('=' Expression)? ','? +TypedefDeclaration ← 'typedef' identifier '=' Type ';' + +FunctionDeclaration ← FunctionSignature ';' +FunctionDefinition ← FunctionSignature Block +FunctionSignature ← Type identifier '(' SignatureArguments? ')' +SignatureArguments ← Type identifier ',' SignatureArguments / + Type identifier ','? +``` + +## Statements + +``` +Block ← '{' Statement* '}' + +Statement ← VariableDefinition / + VariableDeclaration / + IfStatement / + SwitchStatement / + WhileStatement / + DoWhileStatement / + ForStatement / + FlowControlStatement / + AssignmentStatement / + ExpressionStatement + +VariableDefinition ← Type identifier '=' Expression ';' +VariableDeclaration ← Type identifier ';' + +IfStatement ← 'if' Expression Block 'else' Block / + 'if' Expression Block + +SwitchStatement ← 'switch' Expression '{' SwitchCase+ '}' +SwitchCase ← CaseSpecifier Block / + 'default' Block +CaseSpecifier ← 'case' Expression ',' CaseSpecifier / + 'case' Expression ','? + +WhileStatement ← 'while' Expression Block +DoWhileStatement ← 'do' Block 'while' Expression ';' +ForStatement ← 'for' VariableDefinition? ';' Expression ';' AssignmentStatementBody? Block + +FlowControlStatement ← 'continue' ';' / + 'break' ';' / + 'return' Expression? ';' + +AssignmentStatement ← AssignmentStatementBody ';' +AssignmentStatementBody ← AssignmentTargetExpression '=' Expression / + AssignmentTargetExpression '+=' Expression / + AssignmentTargetExpression '-=' Expression / + AssignmentTargetExpression '*=' Expression / + AssignmentTargetExpression '/=' Expression / + AssignmentTargetExpression '%=' Expression / + AssignmentTargetExpression '&=' Expression / + AssignmentTargetExpression '^=' Expression / + AssignmentTargetExpression '|=' Expression / + AssignmentTargetExpression '++' / + AssignmentTargetExpression '--' + +ExpressionStatement ← Expression ';' +``` + +## Types + +``` +Type ← 'const' BasicType / + BasicType '*' / + BasicType '[' Expression ']' / + BasicType 'function' '(' (BasicType ',')* ')' / + BasicType +BasicType ← 'void' / + IntegerType / + 'signed' IntegerType / + 'unsigned' IntegerType / + 'float' / + 'double' / + 'bool' / + 'struct' identifier / + 'enum' identifier / + 'typedef' identifier / + '(' Type ')' +IntegerType ← 'char' / + 'short' / + 'int' / + 'long' +``` + +## Expressions + +``` +AssignmentTargetExpression ← identifier ATEElementSuffix* +ATEElementSuffix ← '[' Expression ']' / + '.' identifier / + '->' identifier + +AtomicExpression ← identifier / + constant / + string-literal / + '(' Expression ')' + +ObjectExpression ← AtomicExpression ObjectSuffix* / + ArrayLiteralExpression / + StructLiteralExpression +ObjectSuffix ← '[' Expression ']' / + '(' CommasExpressionList? ')' / + '.' identifier / + '->' identifier +CommasExpressionList ← Expression ',' CommasExpressionList? / + Expression ','? +ArrayLiteralExpression ← '{' CommasExpressionList '}' +StructLiteralExpression ← '{' StructLiteralBody '}' +StructLiteralBody ← StructLiteralElement ',' StructLiteralBody? / + StructLiteralElement ','? +StructLiteralElement ← '.' identifier '=' Expression + +FactorExpression ← '(' Type ')' FactorExpression / + '&' FactorExpression / + '*' FactorExpression / + '+' FactorExpression / + '-' FactorExpression / + '~' FactorExpression / + '!' FactorExpression / + 'sizeof' FactorExpression / + 'sizeof' Type / + ObjectExpression + +TermExpression ← FactorExpression TermSuffix* +TermSuffix ← '*' FactorExpression / + '/' FactorExpression / + '%' FactorExpression + +ArithmeticExpression ← TermExpression ArithmeticSuffix* +ArithmeticSuffix ← '+' TermExpression / + '-' TermExpression + +BitwiseOpExpression ← ArithmeticExpression '<<' ArithmeticExpression / + ArithmeticExpression '>>' ArithmeticExpression / + ArithmeticExpression '^' ArithmeticExpression / + ArithmeticExpression ('&' ArithmeticExpression)+ / + ArithmeticExpression ('|' ArithmeticExpression)+ / + ArithmeticExpression + +ComparisonExpression ← BitwiseOpExpression '==' BitwiseOpExpression / + BitwiseOpExpression '!=' BitwiseOpExpression / + BitwiseOpExpression '<=' BitwiseOpExpression / + BitwiseOpExpression '>=' BitwiseOpExpression / + BitwiseOpExpression '<' BitwiseOpExpression / + BitwiseOpExpression '>' BitwiseOpExpression / + BitwiseOpExpression + +Expression ← ComparisonExpression ('&&' ComparisonExpression)+ / + ComparisonExpression ('||' ComparisonExpression)+ / + ComparisonExpression +``` + +[![Creative Commons BY-SA License](https://i.creativecommons.org/l/by-sa/4.0/80x15.png)](http://creativecommons.org/licenses/by-sa/4.0/) -- cgit v1.2.3