C Language Syntax: Basics, BNF, and Standard Specs Guide

1. Introduction | The Significance and Benefits of Learning C Language Syntax

2. Basic Structure of C Language Syntax

2.1 Relationship Between Statements and Expressions

int a, b;
b = 3;
a = b + 5; // This line is a "statement", and the b + 5 within it is an "expression"

2.2 Basic Form of Function Definitions and Declarations

int main(void) {
    printf("Hello, World!n");
    return 0;
}

int add(int x, int y); // function declaration (prototype declaration)

2.3 Difference Between External and Local Declarations

• External declaration: Declares variables or functions that are used throughout a file or across multiple files. Typically, global variables and function definitions fall under external declarations.
• Local declaration: Declares variables that are only valid within a function or block. Variables defined inside a function, such as int count = 0;, are examples of this.

int globalValue = 10; // external declaration (global variable)

void func() {
    int localValue = 5; // local declaration (local variable)
}

3. C Language Grammar Glossary (Beginner-friendly Explanation)

3.1 Keywords (keyword)

int, return, if, else, for, while, void, char, struct

3.2 Identifiers (identifier)

• Start with a letter or underscore (_)
• Digits can be used from the second character onward
• Cannot use the same name as a keyword

int score;
float average_value;

3.3 Literals (literal)

• Integer literals: 42, -5
• Floating-point literals: 3.14, -0.5
• Character literals: 'A', 'n'
• String literals: "Hello", "C language"

3.4 Operators (operator)

• Arithmetic operators: +, -, *, /, %
• Comparison operators: ==, !=, <, >, <=, >=
• Logical operators: &&, ||, !
• Assignment operators: =, +=, -=

a = b + 5;
if (x >= 10 && x <= 20) { ... }

3.5 Punctuators (punctuator)

• Semicolon ; (end of statement)
• Curly braces {} (block scope)
• Parentheses () (function calls and precedence grouping)
• Square brackets [] (array access)

4. Understanding C Language Grammar with BNF Notation

4.1 What is BNF

• Non-terminal symbols are enclosed in angle brackets, like <...>.
• Terminal symbols are the keywords or symbols actually used in code.
• ::= means “… is composed of …”.

<if-statement> ::= "if" "(" <expression> ")" <statement> [ "else" <statement> ]

4.2 Representing the Basic Structure of C Language in BNF

<program> ::= <function-definition>

<function-definition> ::= <type-specifier> <identifier> "(" <parameter-list-opt> ")" <compound-statement>

<type-specifier> ::= "int" | "void" | "char" | "float" | "double"

<parameter-list-opt> ::= <parameter-list> | ε

<compound-statement> ::= "{" <statement-list-opt> "}"

<statement-list-opt> ::= <statement-list> | ε

4.3 Example Mapping Between BNF and Actual Code>

<function-definition> ::= "int" "main" "(" ")" "{" <statement-list> "}"
<statement-list> ::= <statement> | <statement-list> <statement>

int main() {
    printf("Hello, World!n");
    return 0;
}

• "int" → return type specifier
• "main" → function name (identifier)
• "(" “)” → indicates no arguments
• "{" ... "}" → compound statement (function body block)
• <statement-list> → sequence of statements inside the function (e.g., printf statement, return statement, etc.)

4.4 Benefits of Learning BNF

• You can understand language specifications structurally
• It makes it easier to visualize how compilers and parsers work
• Applicable to comparing grammars of other languages and to design

5. Overall Grammar Structure Based on the C Standard (C11)

5.1 Major Categories of Grammar

1. Translation Unit (translation unit)
   • The smallest compilation unit that makes up a program, corresponding to a single source file.
   • It also includes header file contents and code after macro expansion.
2. External Declaration (external declaration)
   • Elements such as global variables and function definitions that are available at file scope.
   • External variable declarations, function prototype declarations, function definitions, etc.
3. Function Definition (function definition)
   • Consists of a return type, function name, parameters, and a body block.
   • All executable code, including the main function, is defined as a function.
4. Declaration (declaration)
   • Informs the compiler of the existence of variables, types, and functions.
   • Local variable declarations, typedef declarations, struct/union declarations, etc.
5. Statement (statement)
   • The unit that performs actual operations.
   • Expression statements, compound statements, selection statements (if/switch), iteration statements (for/while/do-while), jump statements (return/break/continue/goto), etc.
6. Expression (expression)
   • Components that combine values, variables, and operators to perform calculations or evaluations.
   • Unary expressions, binary expressions, assignment expressions, function call expressions, etc.

5.2 Grammar Structure Hierarchy Diagram (Conceptual Diagram)

Translation Unit (Translation Unit)
 ├─ External Declaration (External Declaration)
 │    ├─ Function Definition (Function Definition)
 │    └─ Declaration (Declaration)
 └─ Declaration (Declaration)
      └─ type specifiers, initializers, etc.

Statement (Statement)
 ├─ Expression Statement (Expression Statement)
 ├─ Compound Statement (Compound Statement)
 ├─ Selection Statement (If / Switch)
 ├─ Iteration Statement (For / While / Do-While)
 └─ Jump Statement (Return / Break / Continue / Goto)

Expression (Expression)
 ├─ Unary Expression
 ├─ Binary Expression
 ├─ Function Call Expression
 └─ Assignment Expression

5.3 Benefits Based on the Official Specification

• Enables unambiguous code writing
• Allows accurate prediction of compiler and analysis tool behavior
• Makes it easier to understand the structure of code written by others

6. Common Syntax Pitfalls for Beginners

6.1 Forgetting the Semicolon

int a = 10  // No semicolon

int a = 10;

6.2 Misplaced Braces {}

if (x > 0)
    printf("Positiven");
    printf("Always printedn"); // not part of the if

if (x > 0) {
    printf("Positiven");
    printf("Only when positiven");
}

6.3 Declaring Types in the Wrong Order

x = 5;  // used without declaration
int x;

int x;
x = 5;

6.4 Confusing Assignment with Comparison

if (a = 5) { ... } // assigns 5 to a and tests that value

if (a == 5) { ... } // compares a to 5

6.5 Position of Increment/Decrement Operators

• ++i (pre-increment) increments the value then returns it
• i++ (post-increment) returns the value then increments it

int i = 0;
printf("%dn", i++); // outputs 0
printf("%dn", ++i); // outputs 2

7. How to Efficiently Learn C Language Syntax

7.1 Learning from Real Code

#include <stdio.h>

int main(void) {
    int score = 75;

    if (score >= 80) {
        printf("Excellent!\n");
    } else if (score >= 60) {
        printf("Good!\n");
    } else {
        printf("Needs improvement.\n");
    }
    return 0;
}

7.2 Using Syntax Check Tools and Compiler Warnings

• With gcc or clang, use the -Wall option to display warnings to the maximum.
• Always investigate and fix the cause of syntax errors.
• IDEs such as VS Code or CLion can display syntax errors in real time.

gcc -Wall sample.c -o sample

7.3 Referencing Official Specifications and References

• ISO/IEC 9899:2011 (C11) specification
• cppreference.com (C language section)
• Public materials from universities and technical schools

7.4 Using Coding Practice Platforms

• paiza.IO (runable in the browser)
• AtCoder and Aizu Online Judge (competitive programming environments)
• LeetCode (algorithm practice)

7.5 Example Learning Steps

1. Learn basic syntax (variables, operators, control structures)
2. Create small programs yourself (calculators, simple games, etc.)
3. Master function decomposition and header file usage
4. Advance to advanced syntax such as structs and pointers
5. Take on practical small‑scale projects

8. Summary | Long‑Term Benefits of Understanding Syntax

8.1 Faster Acquisition of Other Languages

8.2 Designing Code with Fewer Bugs

• Avoiding type mismatches
• Properly setting variable scope
• Ensuring safe memory operations

8.3 Foundations of Performance Optimization

8.4 Broadening the Project‑Wide Perspective

8.5 Continuous Skill Growth

• Data structures and algorithms
• Network programming
• Understanding operating systems and compilers

9. FAQ | Common Questions About C Language Syntax

• gcc/clang: -Wall option displays detailed warnings
• Visual Studio Code: Extensions provide real-time syntax checking
• clang-tidy: Automatically detects code quality and syntax style issues
• Online execution environments (paiza.IO, JDoodle, etc.): Allow simple syntax checking and execution verification