Which of the following is a group of statements which are part of another statement or functions?

II.C Control Structures

In contrast to its eclectic set of operators, C has an unremarkable collection of control structures. One possible exception is the C for loop, which is more compact and flexible than its analogs in other languages. The purpose of the C control structures, like those in other languages, is to provide alternatives to strictly sequential program execution. The control structures make it easy to provide alternate branches, multi-way branches, and repeated execution of parts of a program. (Of course, the most profound control structure is the subroutine, which is discussed in Section II.D.)

A compound statement is simply a group of statements surrounded by curly braces. It can be used anywhere that a simple statement can be used to make a group of statements into a single entity.

for (i=0; i<10; i++) {

x[i] = 0;

y[i] = 0;

z[i] = 0;

}

In the example above, the three assignment statements form a compound statement because they are enclosed in the curly braces. (The for statement will be discussed later in this section.)

The goto statement is the simplest, the oldest, and the most general control statement. Unfortunately, it is also one of the most easily abused statements, and its use is discouraged. It is seldom used by people who write C programs, but it is often used extensively in C programs that are generated by (written by) other programs. In programs written by people, the goto is usually reserved for handling exceptional conditions, such as branching to an error-handling block of code.

The if statement is used to provide alternative execution paths in a program. In an if statement, one of two alternate possibilities is taken, based on the true/false value of a test expression. The syntax is the following.

if (expr)

statement1;

else

statement2;

The else part is optional, and either statement may be a compound statement. (The expression and the statement above are shown in italics, to indicate that they may be any C expression or C statement. The words if and else are keywords, which must appear exactly as shown, which is why they are not shown in italics.) It is very common for the else part of the if statement to contain another if statement, which creates a chain of if-statement tests. This is sometimes called a cascaded if statement:

if (code==10)

statement1;

else if (code < 0)

statement2;

else if (code > 100)

statement3;

else

statement4;

In the series of tests shown here, only one of the four statements will be executed.

An alternative multi-way branch can be created by a C switch statement. In a switch statement, one of several alternatives is executed, depending on the value of a test expression. Each of the alternatives is tagged by a constant value. When the test expression matches one of the constant values, then that alternative is executed.

The syntax of the switch statement is somewhat complicated.

switch (expr) {

case const1:

statement1;

break;

case const2:

statement2;

break;

default:

statement3;

break;

}

In this skeleton switch statement, expr is the test expression and const1 and const2 symbolize the constants that identify the alternatives. In this example, each alternative is shown terminated by a break statement, which is common but not required. Without these break statements, flow of control would meander from the end of each alternative into the beginning of the following. This behavior is not usually what the programmer wants, but it is one of the possibilities that is present in C's switch statement. The break statement will be discussed further later.

The switch statement is less general than the cascaded if statement, because in a cascaded if statement each alternative can be associated with a complex expression, while in a switch statement each alternative is associated with a constant value (or with several constant values; multiple case labels are allowed).

The switch statement has two advantages over the more flexible cascaded if statement. The first is clarity; when a solution can be expressed by a switch statement, then that solution is probably the clearest solution. The second is efficiency. In a cascaded if statement, each test expression must be evaluated in turn until one of the expressions is true. In a switch statement, it is often possible for the C compiler to generate code that branches directly to the target case.

A while loop lets you repeatedly execute a statement (or group of statements) while some condition is true. It is the simplest iterative statement in C, but it is also very general.

while (ch != EOF)

statement;

The body of this loop (the statement) will be executed repeatedly until the value of the ch variable becomes equal to the value of the standard predefined constant EOF (end of file). Presumably, something in the statement will alter the value of ch so the loop will end. Also, it is presumed that ch is assigned a value prior to the execution of the while statement. (Note that the statement will not be executed if the initial value of ch is EOF.)

It is easy to use a while loop to step through a series of values. For example, the following while loop zeroes the first ten elements of an array named x. (An integer variable named i is used as the array index and as the loop counter.)

i = 0;

while (i < 10) {

x[i++] = 0;

}

A close relative of the while loop is C's do loop. It repeats a statement (or a group of statements) while a condition is true, but the condition is tested at the bottom of the loop, not at the top of the loop. This ensures that the body of the loop will always be executed at least once.

i = 0;

do

x[i] = 0;

while (++i < 10);

As with a while loop, something in the body of the loop or the control expression presumably changes the value of the test expression, so that the loop will eventually terminate.

C's most elaborate loop is the for loop. Here is the general form of the for loop:

for (init_expr; test_expr; inc_expr)

statement;

As in the previous examples, the statement will be repeatedly executed, based on the values of the three control expressions. The init_expr is an initialization expression. It is executed just once—before the body of the loop starts to execute. The test_expr is executed before each iteration of the loop. If it is true, the next iteration will occur, otherwise the loop will be terminated. The inc_expr is executed at the conclusion of every iteration, typically to increment a loop counter.

Here is a typical for loop. It performs the same task as before, setting the first ten elements of an array named x to zero, using a loop counter named i:

for (i=0; i<l0; i++)

x[i] = 0;

Note that the while version of this loop was four lines, while the for version of the loop is just two. This for loop is an example of what Kernighan and Ritchie, authors of the seminal reference book on C, call “economy of expression,” which is one of C's most distinctive traits.

C has two additional flow of control statements, break and continue, that augment the capabilities of the loops that have just been described. The break statement is used to break out of (to immediately terminate) the enclosing do, while, for, or switch statement. Its use is routine in switch statements, to terminate the switch statement at the conclusion of each individual case. In do, while, and for loops, break is often used to terminate the loop prematurely when an error or special condition occurs. Using a break in the body of a loop often simplifies the control expression of the loop, because it allows special case code to be placed elsewhere.

The continue statement is used to immediately start the next iteration of the surrounding do, while, or for loop. It is somewhat like a jump to the end of a loop. For example, suppose a program is reading a list of words from a file. Certain processing must occur for most words, but a few words are just ignored. Here is a pseudocode sketch (pseudocode isn't true C; it merely expresses an idea without following strict syntax) of how that could be written using the continue statement.

while (readaword ()) {

if (word is in the ignore list)

continue;

process a word;

The effect of the continue statement is to skip the process a word part of the loop body for words that are in the ignore list.

Co-begin

Example 12.6

General form of co-begin

The usual semantics of a compound statement (sometimes delimited with begin…end) call for sequential execution of the constituent statements. A co-begin construct calls instead for concurrent execution:

co-begin --all n statements run concurrently

 stmt_1

 stmt_2

 …

 stmt_n

end

Each statement can itself be a sequential or parallel compound, or (commonly) a subroutine call.

Example 12.7

Co-begin in OpenMP

Co-begin was the principal means of creating threads in Algol-68. It appears in a variety of other systems as well, including OpenMP:

#pragma omp sections

{

# pragma omp section

 { printf("thread 1 here\n"); }

# pragma omp section

 { printf("thread 2 here\n"); }

}

In C, OpenMP directives all begin with #pragma omp. (The # sign must appear in column 1.) Most directives, like those shown here, must appear immediately before a loop construct or a compound statement delimited with curly braces.

8.2.3 OpenMP Support for Fork–Join

OpenMP 3.0 also has a fork–join construct. Here is an OpenMP fragment for the fork–join control flow from Figure 8.1:

#pragma omp task

B();

C();

#pragma omp taskwait

The construct task indicates that the subsequent statement can be independently scheduled as a task. In the example, the statement “B();” is run in parallel. The statement could also be a compound statement—that is, a group of statements surrounded by braces. The work in C() is performed by the spawning task, and finally the construct omp taskwait waits for all child tasks of the current task.

There is a catch peculiar to OpenMP: Parallelism happens only inside parallel regions. Thus, for the example to actually fork there must be an enclosing OpenMP parallel construct, either in the current routine or further up the call chain.

Variable capture needs attention. OpenMP tasks essentially capture global variables by reference and local variables by value. In OpenMP parlance, these capture modes are respectively called shared and firstprivate. Sometimes these defaults must be overridden, as the following fragment illustrates:

int foo( int i ) {

 int x, y;

#pragma omp task shared(x)

 x = f(i);

 ++i;

 y = g(i);

#pragma omp taskwait

 return x+y;

}

The shared clause requests that x be captured by reference. Without it, x would be captured by value, and the effect of the assignment x = f(i) would be lost.

3.3.1 Fork–Join

The fork–join pattern lets control flow fork into multiple parallel flows that rejoin later. Various parallel frameworks abstract fork–join in different ways. Some treat fork–join as a parallel form of a compound statement; instead of executing substatements one after the other, they are executed in parallel. Some like OpenMP's parallel region fork control into multiple threads that all execute the same statement and use other constructs to determine which thread does what.

Another approach, used in Cilk Plus, generalizes serial call trees to parallel call trees, by letting code spawn a function instead of calling it. A spawned call is like a normal call, except the caller can keep going without waiting for the callee to return, hence forking control flow between caller and callee. The caller later executes a join operation (called “sync” in Cilk Plus) to wait for the callee to return, thus merging the control flow. This approach can be implemented with an efficient mechanism that extends the stack-oriented call/return mechanism used for serial function calls.

Fork–join should not be confused with barriers. A barrier is a synchronization construct across multiple threads. In a barrier, each thread must wait for all other threads to reach the barrier before any of them leave. The difference is that after a barrier all threads continue, but after a join only one does. Sometimes barriers are used to imitate joins, by making all threads execute identical code after the barrier, until the next conceptual fork.

The fork–join pattern in Cilk Plus is structured in that the task graph generated is cleanly nested and planar, so the program can be reasoned about in a hierarchical fashion. When we refer to the fork–join pattern in this book we will be specifically referring to this structured form.

13.5.2.12 Statement convention examples

Listed as follows is a set of conventions for C++ that address the issues of statement structure. There are other choices that are reasonable and effective in preventing bugs.

▪

Do indent four spaces for nested control-flow constructs.

Do indent four spaces for nested class members.

Do split lines that run over eighty characters:

Break after a comma.

Break before an operator.

Indent eight spaces from the left edge of the beginning of the statement.

Do put opening braces on the same line as the keyword they're associated with.

Do put closing braces on a separate line, indented to the same level as the associate keyword.

Do follow the if, else, while, for, and do keywords with a compound statement block, rather than a simple statement, even if the block contains only one or even zero statements.

Don't put spaces around the reference operators “.” and “->” or between unary operators and their operands.

Do put spaces between binary operators and their operands.

Do conclude the code after a case statement with a break statement.

Do include a default case in a switch statement.

Avoid using do while loops.

Do put each simple statement on a separate line.

Don't assign more than one variable in a statement.

Do parenthesize expressions with more than one operator, so that the default precedence rules are made plain.

Listed as follows is a set of conventions for Java that address the issues of statement structure. There are other choices that are reasonable and effective in preventing bugs.

▪

Do split lines that run over eighty characters:

Break after a comma.

Break before an operator.

Break after a parenthesis.

Do indent one tab stop for nested control constructs.

Do indent one tab stop for nested class members.

Do put an open brace on the same line as the declaration statement.

Do put a closing brace on a separate line, indented to the same level as the first keyword of the declaration statement.

Do put each simple statement on a separate line.

Don't put extra parentheses in a return statement.

Do indent statements in a compound statement one level.

Do put braces around the statements of a compound statement, even if there is only one statement in the block.

Do put an open brace on the same line as a control-flow statement.

Do put a closing brace on a separate line, indented to the same level as the first keyword of the control-flow statement.

Do put case statements at the same level of indentation as the switch statement that controls them.

Do indent the statements of a case one level.

Either put a break statement or a comment that the case falls through at the end of every case.

Don't assign more than one variable in an assignment statement.

Do parenthesize the first operand of the ternary conditional operator.

Do put a blank space after keywords that are followed by parentheses (while, if, for, switch).

Do put a blank space after commas in argument lists.

Do put a blank space between binary operators and their operands, except for the dot operator.

Do put a blank space after semicolons in compound statements.

Do put a blank space after cast operators.

Avoid using do while loops.

Example 3.4

Assign truth values to the following:

x−2=3∧x2=4whenx=2

x−2=3∨x2=4whenx=2

¬ (x−4=0)whenx=4

¬(( a−b)=4)∨(a+b)=2when a=5, b=3

Solution

x − 2 = 3 ∧ x2= 4 when x = 2

Substitute x = 2 into the predicate, x − 2 = 3 ∧ x2 = 4 and we get 2 − 3 = 3 ∧ 22 = 4.

The first part of the compound statement is false and the second part is true. Overall, as F ∧ T ⇔ F, the proposition is false.

x – 2 = 3 ∨ x2 = 4 when x = 2

Substitute x = 2 into the predicate and we get

2 − 2 = 3 ∨ 22 = 4

The first part of the compound statement is false and second part is true. As F ∨ T ⇔ T, the proposition is true.

¬(x − 4 = 0) when x = 4

When x = 4 the expression becomes:

¬(4−4=0)⇔¬T⇔F

¬((a−b)=4)∨(a+b)=2 whena=5,b=3¬((a−b)=4)whena=5,b=3gives¬(5−3=4)⇔¬F⇔T(a+b)=2whena=5,b=3gives(5+3)=2⇔8=2⇔F

Overall, T ∨ F ⇔ T so ¬ ((a –b) = 4) ∨ (a + b) = 2 when a = 5, b = 3 is true.

12.5.2.2 Interrupt sequence, omit step

Reason refers to these types of errors as omissions following interruptions, while Silverman refers to them as omissions due to interruptions.

These errors occur when the majority of your attention resources is claimed by internal or external distraction at a critical point in the execution of a sequence of actions. When your attention returns to executing the sequence, you omit one or more steps from the sequence and continue on. These errors are more likely if you performed some action that will be treated as a substitute for the next step of the sequence.

The following is a programming example of this type of error. Coding switch compound statements in C++ and Java involves a double set of repetitions. The construct as a whole requires the switch keyword, an opening brace, a sequence of case statements, and a closing brace. Within a given case, you must provide the case keyword, an integer value followed by a semicolon, a block of one or more statements, and a break statement.

It is very easy to lose your place in a nested set of repetitions. It is easy to be distracted by some event on your computer, such as a task running in the background, which suddenly pops up a window. If this happens, you may unconsciously substitute the response to that window as the next action you should have taken in composing the switch statement. This may cause you to omit an entire case, or even more unfortunately, omit the break statement. In either case, your switch will be syntactically correct and won't be rejected by the compiler.

38.4 SQL/PSM History

SQL/PSM (SQL/Persistent Stored Modules) is an ISO standard mainly defining an extension of SQL with a procedural language for use in stored procedures. This was the work of Andrew Eisenberg of DEC (Digital Equipment Corporation), who was impressed with ADA. Younger readers will not remember DEC or the ADA language and the Department of Defense ADA initiative. The first version was published in 1996 as an extension of SQL-92. Later, SQL followed the COBOL Standard model of separate modules for optional facilities to use with the SQL standard.

It is a block structured language that uses the ADA model; a block has the usual scoping rules. Local variables are declared at the start of a block, the executable cod is in the body and the “condition handling” (error handling) is at the end of the block. The syntax has control flow with the classic if-then-else family, loops, and error signaling. There are also local variables, assignment of expressions to variables and parameters, and (procedural) use of cursors. It also defines an information schema (metadata) for stored procedures.

In practice, you will find SQL venders who have had their own procedural languages which are block structured. Some vendors later added a SQL/PSM dialect, but cannot get rid of their old proprietary languages. This is called the “code museum effect” where the customer base has too much invested in it. Some examples are as follows: MySQL uses only the SQL/PSM procedure headers, but no control flow at all; IBM has a SQL/PSM in DB2; Mimer has a SQL/PSM implementation, and Oracle’s PL/SQL is a SQL/PSM dialect. Informix/SPL is more Algol-like and the T-SQL language in MS SQL Server is a mix of Algol and C. A PostgreSQL add-on implements SQL/PSM (alongside its own procedural language), although it is not part of the core product.

Rules of Inference

The other component are the deductively valid arguments that can be constructed in the logic. An argument is the derivation of a statement from one or more other statements – equivalently, the derivation of one wff from one or more other wffs. The derived statement/wff is the conclusion of the argument; the statements/wffs it is derived from are the premises of that argument.

The supreme responsibility which any system of deductive logic has is to never permit a false conclusion to be derived from true premises. This means that from a set of statements that are true, all other statements derived by means of transformation rules or inference rules will also be true.

The following are some rules of inference used in many systems of propositional logic. All of them fulfill this responsibility, as do the transformation rules listed in Figure 4.6. These inference rules permit us to add a statement to the set of statements consisting of the premises of the argument and any previously derived statements.8

The semantics of this rule is that if we know that both X and Y are true, then we can be sure that X is true. The syntax of this rule (expressed as a function in a string manipulation program, for example) is that if we have (X∧Y) as one line of an argument, then we can write down X as a new line.

The rule of conjunction says that from X and Y, we can derive (X∧Y).9 So if a string manipulation program that includes this rule finds two lines, one X and the other Y, it can generate a new line (X∧Y). Since this rule could be applied by a program to any conjunction, no matter how complex the conjunction and how complex any of its conjuncts, then although the rule itself may seem trivially obvious, it can still be a very useful rule.

The rule of addition says that from X, we can derive (X∨Y). For example, if it’s true that water only flows downhill, then it’s also true that either water only flows downhill or the sun is 10 million miles from the earth. (There is no requirement that an added disjunct be a true statement.)10

The rule of modus ponens says that from (X→Y), and also X, we can derive Y. This is the most widely-used rule of inference in propositional logic. From the truth table for (X→Y), we know that the one and only case in which (X→Y) is false is the case where X is true and Y is false. Since our premises are that (X→Y) is true, and that X is also true, we know that Y cannot be false.

The rule of modus tollens says that from (X→Y) and ~Y, we can derive ~X. It is the corollary of modus ponens. From the truth table for (X→Y), we know that the one and only case in which (X→Y) is false is the case where X is true and Y is false. Since our premises are that (X→Y) and ~Y are both true, we know that X cannot be true.

The rule of chain deduction expresses the transitivity of material implication. It says that from (X→Y) and (Y→Z), we can derive (X→Z).

The rule of disjunctive simplification says that from (X∨Y), and ~X, we can derive Y. For example, if it’s true that either Mike or Steve went to Harvard, and also that Mike went to Stanford (in other words, that Mike didn’t go to Harvard), then it follows that it’s Steve who went to Harvard.

Usually, systems of propositional logic use only a few rules of inference. It is interesting to note that none of the rules of inference for material implication are necessary. Since (X→Y) is equivalent to (~X∨Y), we can transform any statement containing (X→Y) into a statement containing (~X∨Y). In particular, the full functionality of propositional logic is possible in a system in which only conjunction, disjunction and negation are used to form statements – a system such as SQL, for example. In such a system, the only rules of inference that would apply are those that warrant the derivation of a statement from one or more other statements when all compound statements are expressed with the connectives “∧”, “∨” and “~”, and with no other connectives.