II.4 Components of a Programming Language

⬆️ P-I.II. Programming Fundamentals · Question Bank · Chapter II (2016–2026)

🧠

Remember: Tokens are words; syntax is grammar; semantics is meaning.

Start here — what you should be able to do

Classify identifiers, literals, keywords, operators and punctuation.
Separate syntax, static semantic checks and logic errors.
Read a simple grammar rule and explain precedence.

Reading order: foundation checks → full notes and examples → exam traps → self-test without notes → past-paper answers. All sections below remain part of the topic; code examples are kept in full.

Foundation checks

Three different kinds of mistake

Kind	Example	What it means
Syntax	`int x = ;`	The token arrangement violates the grammar.
Static semantic/type error	Using an undeclared variable	The form may parse, but names/types are invalid.
Logic error	Adding when multiplication was required	Legal code solves the wrong problem.

Do not equate all semantics with logic errors: compilers check many semantic constraints. Comments and whitespace: normally carry no runtime operation, but they separate tokens; removing them carelessly can change the program. Grammar: BNF defines valid forms; a grammar is not automatically unambiguous.

1. Core Concepts

Syntax: the formal rules governing how valid statements are constructed (the grammar of the language). A compiler checks syntax first — a syntax error stops compilation entirely.
Semantics: the meaning/behavior associated with syntactically valid statements. Static semantic rules include name and type checks; dynamic semantics describes execution. Logic errors are a separate failure to solve the intended problem.
Tokens: the smallest meaningful units the compiler recognizes — every program is broken into tokens before parsing. Categories:
- Keywords: reserved words with fixed meaning (int, if, return, class) — cannot be redefined or used as identifiers
- Identifiers: programmer-defined names for variables, functions, classes, etc.
- Literals/Constants: fixed values written directly (42, 3.14, 'x', "text", true)
- Operators: symbols performing operations (arithmetic, relational, logical, bitwise, assignment)
- Punctuators/Separators: symbols that structure code without performing computation (;, ,, { }, ( ), [ ])
Comments: non-executable annotations for humans; replaced during translation, with token separation preserved

2. Syntax vs Semantics — Example

int x = 5 / 0;

Syntactically valid — this line parses fine, follows all grammar rules
Semantically problematic — division by zero is undefined behavior/runtime error, even though the syntax is correct

Contrast with:

int x = 5 0;

This is a syntax error — missing an operator between 5 and 0; the compiler rejects it before it can even consider meaning

3. Grammar and Rules

Every language defines its syntax formally, often using grammar notations like BNF (Backus-Naur Form), which the compiler's parser uses to validate structure
A statement must be well-formed (follows the grammar) to compile; it must additionally be meaningful in context (e.g. correct types) to behave as intended

4. 💻 Code Examples: C & C++

The syntax-vs-semantics example from above, made runnable, plus tokens labelled:

#include <stdio.h>
int main(void) {
    int x = 5 / 2;       /* syntactically valid; semantics: integer division -> 2 */
    // int y = 5 0;       // would be a SYNTAX error -- missing operator, won't compile
    printf("%d\n", x);    // tokens: printf ( "%d\n" , x ) ;
    return 0;
}

C++:

#include <iostream>
using namespace std;
int main() {
    int x = 5 / 2;        // syntactically valid; semantics: integer division -> 2
    // int y = 5 0;        // would be a SYNTAX error
    cout << x << endl;      // tokens: cout << x << endl ;
    return 0;
}

int, return are keywords; x, main are identifiers; 5, 2 are literals; /, << are operators; ;, (, ) are punctuators — every one of these is a token

5. MCQ Traps

Error distinction: syntax and static semantic errors can be diagnosed during translation; logic errors are defects in the intended algorithm.
Keywords are part of the language's fixed vocabulary; identifiers are chosen by the programmer — a keyword can never double as an identifier
Punctuators (like ; or {}) are tokens too, but they don't perform operations the way operators do
Comments carry no runtime operation; they are replaced during translation and can separate tokens. Do not remove token-separating comments without whitespace.

6. ✅ Self-Test Questions (with Answers)

Q1. Differentiate syntax from semantics with one example each.

Answer

Syntax: rules for arranging tokens into valid statements; the parser checks these rules.
Static semantics: names, types and other contextual constraints; many are checked by the compiler.
Dynamic meaning: what valid code does during execution.
Logic error: valid code fails the programmer's intended task; testing and tracing are needed.
Example: a missing semicolon is syntax; an undeclared name is a static semantic error; using the wrong formula is logic.

// SYNTAX ERROR -- breaks the grammar; the compiler rejects it
// int x = 5 0;      // no operator between 5 and 0 -> will not compile
// if (a > b         // missing ) and ;              -> will not compile

// SEMANTIC / LOGIC ERROR -- grammatically perfect, meaning is wrong
int length = 5, width = 3;
int area = length + width;   // legal C++, but the formula should be *
cout << area;                // prints 8; the correct area is 15

Aspect	Syntax	Semantics
Concerns	Form / structure of statements	Meaning / behaviour of statements
Checked by	Parser during translation	Static semantic checks by compiler; intended behaviour by reasoning/testing
On violation	Syntax diagnostic	May be a type diagnostic, invalid runtime operation, or logic defect
Typical error	Missing ; , unbalanced braces	Wrong operator or formula, wrong condition

MCQ trap: if (x = 5) is semantically wrong, not syntactically — = is a legal assignment whose result (5) is non-zero, so the condition is always true; the intended test was ==. Similarly int x = 5 / 2; is valid syntax whose semantics give 2, because integer division truncates the fractional part.

Q2. List the five categories of tokens found in a typical high-level language.

Answer — key points

A token is the smallest unit of a program meaningful to the compiler, produced by the lexical analyser as it scans the source text.
Every C/C++ program reduces to a stream drawn from exactly five categories:

#	Category	Description	Examples
1	Keywords	Reserved words with fixed meaning; cannot be redefined	int, if, while, return, class, void
2	Identifiers	Programmer-chosen names for variables, functions, classes	total, main, studentAge, _count
3	Constants / Literals	Fixed values written directly in the code	42, 3.14, 'x', "text", true
4	Operators	Symbols that perform an operation on operands	• - * / % == && ! << ++
5	Punctuators / Separators	Structure the code without computing anything	; , ( ) { } [ ] #

if (count == 10) total += price;
// if      -> keyword
// count, total, price -> identifiers
// ==, +=  -> operators
// 10      -> literal
// ( ) ;   -> punctuators
// 11 tokens in total

Lexical detail: comments/whitespace generally carry no runtime operation, but can separate tokens; removing them carelessly can change tokenisation.

Q3. Why is `5 0;` (missing operator) a syntax error while `5/0;` is not?