Control Structures
Frag provides a complete set of control structures including
commands for conditional execution and looping. Frag control structures
are implemented as commands that take Frag code as arguments.
Some of the arguments are expressions and code, which are both evaluated
by the control structure on the fly.
An if-statement lets you conditionally process a code block when the
specified boolean condition (an expression) evaluates to true. In Frag
the if-statement consists of at least one expression and a code block (the then-part),
an arbitrary number of else-if-parts (consisting of alternative conditions and code blocks),
and an optional else-part. The else-part is executed, if all conditions of then-part and
else-if-parts evaluate to false.
The syntax is:
if <condition> <then-part> ?else if <else-if-part>? ... ?else <else-part>?
For example, the following code prints true because the condition is true.
if {1 < 2} {puts "true"}
Another simple example is an if statement changing the value of a variable
conditionally:
if {$x > 100} {
set x 0
}
Another example is an if statement which evaluates two conditions,
and prints one of three possible messages to the
standard output.
if {$vbl == 1} {
puts "vbl is one"
} else if {$vbl == 2} {
puts "vbl is two"
} else {
puts "vbl is not one or two"
}
The following code demonstrates multiple alternative if-branches (else, else if)
selected upon a user input.
set a [gets]
if {$a > 5} {
puts "greater than 5"
} else if {$a > 100} {
puts "greater than 100"
} else {
puts "less than 6"
}
switch implements a generalized case mechanism that covers many possible combinations
of switch and case values, usually to be applied instead of using multiple consecutive if-statements.
The syntax is:
switch <matchString> <body>'
Frag's switch implements a switch statement that switches over a matchString.
The body consists of pairs of lists of the form: <matchList> <code>.
Each matchList contains a list of elements that are matched against the match string
using glob style matching (For a detailed description of the pattern matching syntax,
see Pattern Matching).
If a match is found, the corresponding code is executed, and - in contrast to
switch statements in other languages - the switch breaks and continues with statements
are the switch statements.
For instance, the following code returns 2 because y has the value A:
set x 1
set y A
switch $y {
A {set x 2}
B {set x 3}
C {set x 4}
}
get x
The following code also returns 2 because y is matched in the list given as the first match element list:
set x 1
set y A
switch $y {
{A B C} {set x 2}
D {set x 4}
}
get x
To match a string with spaces, we must put it into a list with 1 argument:
set x 1
set y "A B C"
switch $y {
{"A B C"} {set x 2}
D {set x 4}
}
get x
As switch uses pattern matching, we can use * to define defaults:
set x 1
set y N
switch $y {
A* {set x 2}
B {set x 3}
* {throw [Exception create -msg "unknown kind: $y"]}
}
get x
A while loop is a control structure that allows a block of code to be
executed repeatedly based on a given boolean condition (an expression).
The condition is first evaluated, and if the condition is true,
the code within the block is executed.
This repeats until the condition becomes false.
The syntax is:
while <condition> <body>'
The boolean condition is checked first, and if it evaluates to
true, the body is executed. This sequence is repeated until
condition evaluates to false.
An example is a while loop, which prints ten lines of the form
x is 0, x is 1, ...
set x 0
while {$x < 10} {
puts "x is $x"
set x ($x + 1)
}
A for-loop is a control structure that allows code to be
executed repeatedly based on a given boolean condition (an expression).
Unlike the while-loop, the for-loop has an argument for initialization
and for incrementing of a value, such as a loop counter.
The syntax is:
for <intialization> <condition> <step> <body>
The code in intialization is evaluated first. Then the
boolean condition is checked, and if it evaluates to true, the body is
executed, and finally step is executed. This sequence is executed until
condition evaluates to false.
The following code shows a for-loop that appends integers to a variable until
the value 6 is reached. The result is a list of integers with the values ranging
from 1 to 5.
set a {}
for {set i 1} {$i < 6} {set i ($i + 1)} {
append a $i
}
puts "Result = [get a]"
Another example is a for loop, which prints ten lines of the form
x is 0, x is 1, ...
for {set x 0} {$x < 10} {set x ($x + 1)} {
puts "x is $x"
}
A foreach-loop is a control structure that allows code to be
executed repeatedly for each element of a list. A list variable is used
to iterate through the list members.
The syntax is:
foreach <var list> <list> <body>
foreach iterates over a list and executes the body for each element in the list.
The value of the list element is assigned to the variable in var list.
Optionally, var list can contain mulitple (= n) elements.
Then the list is traversed by sequences of n elements.
That is, the list must contain a number of elements that can be divided by n.
An example is a foreach loop, which prints each element in
a given list:
foreach element {a b c e r t b} {
puts "list element is $element"
}
In the following code, numbers in a list are appended to another list in
mulitple iterations of a foreach loop.
set a {}
foreach i {1 2 3 4 5} {
append a $i
}
puts "list = [get a]"
The following code demonstrates how a list is processed using a list of
two variables:
set x {}
foreach {a b} {1 2 3 4} {
append x $b $a
}
puts "list = [get x]"
The break-statement breaks the control flow of the loop (such as while, for, etc.)
in which it is placed and continues the execution after that loop.
The syntax is simply:
break
In the following example, the loop ends at element "8".
for {set x 0} {$x < 10} {set x ($x + 1)} {
puts "x is $x"
if {$x == 8} { break }
}
The continue-statement breaks the control flow of the loop (such as while, for, etc.)
in which it is placed and continues with the next iteration of the loop.
The syntax is simply:
continue
Consider a continue statement in a for-loop:
set a {}
for {set i 1} {$i <= 4} {set i ($i + 1)} {
if {$i == 3} continue
append a $i
}
get a
This returns the list 1 2 4 because the continue happens in the third iteration
of the loop, and for all other iterations $i is appended to a.
