Statement (computer science)

From Wikipedia, the free encyclopedia
Jump to navigation Jump to search

In computer programming, a statement is a syntactic unit of an imperative programming language that expresses some action to be carried out.[1] A program written in such a language is formed by a sequence of one or more statements. A statement may have internal components (e.g., expressions).

Many programming languages (e.g. Ada, Algol 60, C, Java, Pascal) make a distinction between statements and definitions/declarations. A definition or declaration specifies the data on which a program is to operate, while a statement specifies the actions to be taken with that data.

Statements which cannot contain other statements are simple; those which can contain other statements are compound.[2]

The appearance of a statement (and indeed a program) is determined by its syntax or grammar. The meaning of a statement is determined by its semantics.

Simple statements[edit]

Simple statements are complete in themselves; these include assignments, subroutine calls, and a few statements which may significantly affect the program flow of control (e.g. goto, return, stop/halt). In some languages, input and output, assertions, and exits are handled by special statements, while other languages use calls to predefined subroutines.

  • assignment
    • Fortran: variable = expression
    • Pascal, Algol 60, Ada: variable := expression;
    • C, C#, C++, PHP, Java: variable = expression;
  • call
    • Fortran: CALL subroutine name(parameters)
    • C, C++, Java, PHP, Pascal, Ada: subroutine name(parameters);
  • assertion
    • C, C++, PHP: assert(relational expression);
    • Java: assert relational expression;
  • goto
    • Fortran: GOTO numbered-label
    • Algol 60: goto label;
    • C, C++, PHP, Pascal: goto label;
  • return
    • Fortran: RETURN value
    • C, C++, Java, PHP: return value;
  • stop/halt/exit
    • Fortran: STOP number
    • C, C++: exit(expression)
    • PHP: exit number;

Compound statements[edit]

Compound statements may contain (sequences of) statements, nestable to any reasonable depth, and generally involve tests to decide whether or not to obey or repeat these contained statements.

Notation for the following examples:
  • <statement> is any single statement (could be simple or compound).
  • <sequence> is any sequence of zero or more <statements>
Some programming languages provide a general way of grouping statements together, so that any single <statement> can be replaced by a group:
  • Algol 60: begin <sequence> end
  • Pascal: begin <sequence> end
  • C, PHP, Java: { <sequence> }
Other programming languages have a different special terminator on each kind of compound statement, so that one or more statements are automatically treated as a group:
  • Ada: if test then <sequence> end if;

Many compound statements are loop commands or choice commands. In theory only one of each of these types of commands is required. In practice there are various special cases which occur quite often; these may make a program easier to understand, may make programming easier, and can often be implemented much more efficiently. There are many subtleties not mentioned here; see the linked articles for details.

  • count-controlled loop:
    • Algol 60: for index := 1 step 1 until limit do <statement> ;
    • Pascal: for index := 1 to limit do <statement> ;
    • C, Java: for ( index = 1; index <= limit; index += 1) <statement> ;
    • Ada: for index in 1..limit loop <sequence> end loop
    • Fortran 90:
      DO index = 1,limit
      END DO
  • condition-controlled loop with test at start of loop:
    • Algol 60: for index := expression while test do <statement> ;
    • Pascal: while test do <statement> ;
    • C, Java: while (test) <statement> ;
    • Ada: while test loop <sequence> end loop
    • Fortran 90:
      DO WHILE (test)
      END DO
  • condition-controlled loop with test at end of loop:
    • Pascal: repeat <sequence> until test; { note reversed test}
    • C, Java: do { <sequence> } while (test) ;
    • Ada: loop <sequence> exit when test; end loop;
  • condition-controlled loop with test in the middle of the loop:
    • C: do { <sequence> if (test) break; <sequence> } while (true) ;
    • Ada: loop <sequence> exit when test; <sequence> end loop;
  • if-statement simple situation:
    • Algol 60:if test then <unconditional statement> ;
    • Pascal:if test then <statement> ;
    • C, Java: if (test) <statement> ;
    • Ada: if test then <sequence> end if;
    • Fortran 77+:
      IF (test) THEN
      END IF
  • if-statement two-way choice:
    • Algol 60:if test then <unconditional statement> else <statement> ;
    • Pascal:if test then <statement> else <statement> ;
    • C, Java: it (test) <statement> else <statement> ;
    • Ada: if test then <sequence> else <sequence> end if;
    • Fortran 77+:
      IF (test) THEN
      END IF
  • case/switch statement multi-way choice:
    • Pascal: case c of 'a': alert(); 'q': quit(); end;
    • Ada: case c is when 'a' => alert(); when 'q' => quit(); end case;
    • C, Java: switch (c) { case 'a': alert(); break; case 'q': quit(); break; }
  • Exception handling:
    • Ada: begin protected code except when exception specification => exception handler
    • Java: try { protected code } catch (exception specification) { exception handler } finally { cleanup }
    • Python: try: protected code except exception specification: exception handler else: no exceptions finally: cleanup


Apart from assignments and subroutine calls, most languages start each statement with a special word (e.g. goto, if, while, etc.) as shown in the above examples. Various methods have been used to describe the form of statements in different languages; the more formal methods tend to be more precise:

  • Algol 60 used Backus–Naur form (BNF) which set a new level for language grammar specification.[3]
  • Up until Fortran 77, the language was described in English prose with examples,[4] From Fortran 90 onwards, the language was described using a variant of BNF.[5]
  • Cobol used a two-dimensional metalanguage.[6]
  • Pascal used both syntax diagrams and equivalent BNF.[7]

BNF uses recursion to express repetition, so various extensions have been proposed to allow direct indication of repetition.

Statements and keywords[edit]

Some programming language grammars reserve keywords or mark them specially, and do not allow them to be used as identifiers. This often leads to grammars which are easier to parse, requiring less lookahead.

No distinguished keywords[edit]

Fortran and PL/1 do not have reserved keywords, allowing statements like:

  • in PL/1:
    • IF IF = THEN THEN ... (the second IF and the first THEN are variables).
  • in Fortran:
    • IF (A) X = 10... conditional statement (with other variants)
    • IF (A) = 2 assignment to a subscripted variable named IF
As spaces were optional up to Fortran 95, a typo could completely change the meaning of a statement:
  • DO 10 I = 1,5 start of a loop with I running from 1 to 5
  • DO 10 I = 1.5 assignment of the value 1.5 to the variable DO10I

Flagged words[edit]

In Algol 60 and Algol 68, special tokens were distinguished explicitly: for publication, in boldface e.g. begin; for programming, with some special marking, e.g., a flag ('begin), quotation marks ('begin'), or underlined (begin on the Elliott 503). This is called "stropping".

Tokens that are part of the language syntax thus do not conflict with programmer-defined names.

Reserved keywords[edit]

Certain names are reserved as part of the programming language and can not be used as programmer-defined names. The majority of the most popular programming languages use reserved keywords. Early examples include FLOW-MATIC (1953) and COBOL (1959). Since 1970 other examples include Ada, C, C++, Java, and Pascal. The number of reserved words depends on the language: C has about 30 while COBOL has about 400.


Semantics is concerned with the meaning of a program. The standards documents for many programming languages use BNF or some equivalent to express the syntax/grammar in a fairly formal and precise way, but the semantics/meaning of the program is generally described using examples and English prose. This can result in ambiguity.[8] In some language descriptions the meaning of compound statements is defined by the use of 'simpler' constructions, e.g. a while loop can be defined by a combination of tests, jumps, and labels, using if and goto.

The semantics article describes several mathematical/logical formalisms which have been used to specify semantics in a precise way; these are generally more complicated than BNF, and no single approach is generally accepted as the way to go. Some approaches effectively define an interpreter for the language, some use formal logic to reason about a program, some attach affixes to syntactic entities to ensure consistency, etc.


A distinction is often made between statements, which are executed, and expressions, which are evaluated. The value obtained from an expression is often used as part of a statement e.g. assignment variable := expression;

Some programming languages (e.g. C, C++) allow some statements to provide a result (technically all statements provide a result, but this result is often of type 'void' and can't be used for anything). The most useful statement which provides a result is an assignment, the result being the value just assigned.

This can be useful for multiple initialisation:

i = j = 0; which is treated as i = (j = 0);

It can also result in simple finger trouble completely changing the meaning of some code:

if (i == j) {. . . }; tests to see if i is equal to j
if (i = j) { . . . }; assigns the value of j to i and then tests to see if that value is non-zero.

Some languages allow multiple assignment (Algol 60) but don't allow assignments to appear in expressions (Algol 60, Pascal).


Most languages have a fixed set of statements defined by the language, but there have been experiments with extensible languages that allow the programmer to define new statements.

See also[edit]


  1. ^ "statement". webopedia. Retrieved 2015-03-03.
  2. ^ Revised ALGOL 60 report section. 4.1."ALGOL 60". Retrieved January 23, 2021.
  3. ^ Revised ALGOL 60 report section 1.1."ALGOL 60". Retrieved January 23, 2021.
  4. ^ ANSI FORTRAN 66 standard"FORTRAN 66" (PDF). Retrieved February 19, 2021.
  5. ^ ANSI FORTRAN 95 standard"Fortran95" (PDF). Retrieved February 19, 2021.
  6. ^ Cobol manual."COBOL" (PDF). Retrieved January 23, 2021.
  7. ^ Pascal User Manual and Report Appendix D."Pascal" (PDF). Retrieved February 19, 2021.
  8. ^ Trouble spots in Algol 60"Trouble Spots" (PDF). Retrieved February 24, 2021.

External links[edit]