Conditional structures: Difference between revisions

=={{header|11l}}==

===if-else===

foo()

E I x == 1

bar()

E

===switch===

0

foo()

bar()

E

=={{header|360 Assembly}}==

Here are the branch mnemonic opcodes:

B label Unconditional

BR Rx "

BNMR Rx "

BNZ label Branch if Not Zero

The ASM (Assembler Structured Macros) toolkit brings structures to IBM assembler 360.

opcode,op1,rel,op2

opcode,op1,rel,op2,OR,opcode,op1,rel,op2

CASE 7 case 7

LA R5,4 r5=4

=={{header|6502 Assembly}}==

6502 Assembly has 8 conditional branch instructions; each instruction will test the appropriate flag and condition and jump between -128 and 127 bytes.

To understand these conditional instructions, it is helpful to remember that the comparison instructions (CMP, CPX, CPY) set the flags as if a subtraction had occurred:

Following these instructions, the accumulator will still hold 10 but the flags are set as if you had instructed the processor to perform 10 - 11.

The result is -1, so the sign flag will be set, the zero flag will be cleared, the overflow flag will be cleared, and the carry flag will be set.

BEQ ;Branch on EQual - branch when the zero flag is set.

;The zero flag is set when the result of an operation is zero

;a subtraction produced a borrow and cleared if an addition/subtraction

;does not produce a carry/borrow. The carry flag also holds bits

In the following example, the branch will be taken if memory location Variable holds 200:

CMP Variable

BEQ #3 ;if equal, skip ahead 3 bytes...

CLC ;if unequal, continue executing instructions

ADC #1

Because you don't have to perform a comparison to set the flags, you can perform very fast checks in iterative loops:

Loop: ...do something

DEX

This code will loop until X is zero.

Most assemblers will figure out the correct offset for you if you use a label in place of the offset after a branch instruction, as in the above example.

A jump table is a list of subroutine addresses, which can be indexed like any other array. The 6502 has no indirect call command, but it can be created in software using an indexed jump table. One method of doing this is spoofing a return address and using the return from subroutine command to "return" to the desired subroutine.

dw foo-1 ;each is a label to a section of code that ends in an RTS

dw bar-1

; If done properly, return spoofing will not corrupt the stack.

=={{header|68000 Assembly}}==

Like [[6502 Assembly]], 68000 Assembly has several different condition states the CPU can use to branch. As is typical with assembly languages, branching code is less straightforward than on high-level languages. There is no "if" statement per se; the correct branch to use depends more so on the expression being evaluated.

===CMP===

The most commonly used comparator is <code>CMP</code>. It can operate at byte, word, or long length. Anything outside of the "range" of its size parameter is ignored.

CMP.B #0,D0 ;equals zero, so zero flag is set.

Other than its size parameter, <code>CMP</code> works very similar to [[6502 Assembly]]. It returns both a test for equality and a size comparison (i.e. which number is greater than the other.) This chart from [http://www.easy68k.com/paulrsm/doc/trick68k.htm 68000 Tricks and Traps] sums it up nicely. If you use <code>CMP D0,D1</code> at any data size, this is what you get:

===Bit Testing===

Individual bits can be tested with <code>BTST</code>, <code>BSET</code>, <code>BCLR</code>, and <code>BCHG</code>. The <code>BTST</code> command takes a bit as its left operand and the value being tested in the right (either a data register, address register with or without parentheses, or memory address).

BNE goHere ;if that bit is 1, branch to "goHere"

<code>BSET</code>, <code>BCLR</code>, and <code>BCHG</code> are similar, in that they also allow you to branch based on the value of the bit being tested. However, they also alter the bit in the destination that was tested, AFTER the test. The new state of that bit is not reflected in the test results. Branching occurs as if you used <code>BTST</code> instead. <code>BSET</code> makes the bit in the destination 1, <code>BCLR</code>makes it zero, and <code>BCHG</code> flips it.

These concepts can be emulated in assembly but it's a bit tricky for beginners to understand. The branch condition isn't always what you would expect. Sometimes it is reversed depending on what is easier to check. This is a common way to have an <code>IF condition==true THEN do something ELSE do nothing</code> style of statement. The code checks if <code>D0 == 3</code> and if it does, adds 7. If <code>D0 != 3</code>, execution just continues as normal.

BNE doNothing

ADD.L #7,D0

doNothing:

Rather than branch to a different section of code if <code>D0 == 3</code>, the program branched if it <b>DIDN'T</b> equal 3, skipping the add 7.

There is no built-in way to "default" if none of the expected cases match. A bounds check will have to be programmed in manually. Most of the time when writing a return spoof the programmer already knows what the maximum possible cases will be.

DC.L foo,bar,baz,default ;case 0, case 1, case 2, case 3. (Case 0,1,2 are the "valid" cases.)

; D0 is the case selector variable (byte-sized)

default:

=={{header|AArch64 Assembly}}==

{{works with|as|Raspberry Pi 3B version Buster 64 bits}}

/* ARM assembly AARCH64 Raspberry PI 3B */

/* program condstr64.s */

.include "../includeARM64.inc"

=={{header|Action!}}==

INT i

FI

OD

{{out}}

[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Conditional_structures.png Screenshot from Atari 8-bit computer]

=={{header|Ada}}==

===if-then-else===

My_Var : Restricted;

else

-- do something

===conditional expressions===

Ada 2012 introduces conditional expressions, which are allowed anywhere an expression is allowed (e.g.: in a numeric literal, aggregate, etc.). A conditional expression can either be an if expression or case expression. Conditional expressions must be surrounded by parentheses.

====if expression====

Op : Operation;

Result : Integer;

elsif Op = Divide then

A / B

====case expressions====

Add => A + B,

Subtract => A - B,

Divide => A / B

);

===case with a default alternative===

Today : Days;

when others =>

Accumulate_Sales;

===case without a default===

I.e., the following code is syntactically incorrect:

when Monday =>

Compute_Starting_Balance;

Accumulate_Sales;

-- ignore Saturday and Sunday

The syntactically correct version:

when Saturday | Sunday =>

null; -- don't do anything, if Today is Saturday or Sunday

when Tuesday .. Thursday =>

Accumulate_Sales;

===select===

====Conditional Accept====

accept first_entry;

-- do something

-- do something

or terminate;

====Conditional entry call====

A selective entry call provides a way to time-out an entry call.

Without the time-out the calling task will suspend until the entry call is accepted.

My_Task.Start;

or

delay Timeout_Period;

The entry Start on the task My_Task will be called.

If My_Task accepts the entry call before the timer expires the timer is canceled. If the timeout expires before the entry call is accepted the entry call is canceled.

=={{header|Aikido}}==

===Conditional Expressions===

var x = loggedin ? sessionid : -1

===if..elif..else===

if (value > 40) {

println ("OK")

println ("RETRY")

}

===switch===

switch (arg) {

case "-d":

println ("RETRY")

}

=={{header|Aime}}==

===If-elif-else===

// first condition is true...

} elif (c2) {

} else {

// none was true...

=={{header|ALGOL 60}}==

'''if''' X=Y '''then''' K:=I

An example:

'IF' I<J 'THEN' OUTSTRING(1,'(' : I<J')')

OUTSTRING(1,'(' J=')');

OUTINTEGER(1,J)

Algol 60 has also a switch structure:

declaration::= '''switch''' switch:=list_of labels

statement::= '''goto''' switch[expression]

An example:

...

'GOTO' TARGET(/J/);

L1: OUTSTRING(1,'('AA')');

L2: OUTSTRING(1,'('BB')');

=={{header|ALGOL 68}}==

=={{header|ALGOL W}}==

integer a, b, c;

write( case c - a of ( "one", "two", "three", "four" ) )

{{out}}

<pre>

The second and third arguments should be blocks (aka anonymous functions or thunks).

if: condition then: {

// condition is true...

// condition is false...

}

===IfTrue/IfFalse===

One can also send a message to the boolean objects true and false:

condition.ifTrue: { /* condition is true... */ } ifFalse: { /* condition is false... */ }

=={{header|AmigaE}}==

'''IF-THEN-ELSE'''

-> if condition is true...

ELSEIF condition2

ELSE

-> if all other conditions are not true...

or on one single line:

'''Ternary IF THEN ELSE'''

The IF-THEN-ELSE can be used like ternary operator (?: in C)

'''SELECT-CASE'''

CASE n1

-> code

DEFAULT

-> no one of the previous case...

Another version allows for ranges:

CASE n1

-> code

DEFAULT

-> none of previous ones

The biggest among n1, n2 and so on, must be not bigger than max_possible_value.

=={{header|Apex}}==

===if-then-else===

foo();

} else if (s == 'Bye World') {

} else {

deusEx();

Java also supports [[wp:Short-circuit_evaluation|short-circuit evaluation]]. So in a conditional like this:

aMethod();

<tt>obj.foo()</tt> will not be executed if <tt>obj != null</tt> returns false. It is possible to have conditionals without short circuit evaluation using the <tt>&</tt> and <tt>|</tt> operators (from [[Bitwise operations]]). So in this conditional:

aMethod();

You will get a null pointer exception if obj is null.

===ternary===

===switch===

=={{header|AppleScript}}==

===if-then-else===

set i to 0

else

return "odd"

=={{header|ARM Assembly}}==

{{works with|as|Raspberry Pi}}

/* ARM assembly Raspberry PI */

bx lr /* return */

=={{header|Arturo}}==

===if?-else===

if? num=2 [

else [

print "something went wrong..."

{{out}}

===case-when?===

case [num]

when? [<2] -> print [num ": it's less than 2"]

else -> print [num ": the number is too big"]

]

{{out}}

=={{header|Astro}}==

foo()

elif x == 1:

_ => qux()

=={{header|AutoHotkey}}==

===if, else if, else===

If x

MsgBox, x is %x%

MsgBox, x is %x%

Else

===ternary if===

y = 1

var := x > y ? 2 : 3

===while (looping if)===

MsgBox, %A_Index% is less than 3

=={{header|AutoIt}}==

===If, ElseIf, Else===

statements

...

...

EndIf

===Select Case===

Case <expression>

statement1

...]

EndSelect

===Switch Case===

Case <value> [To <value>] [,<value> [To <value>] ...]

statement1

...]

EndSwitch

--[[User:BugFix|BugFix]] ([[User talk:BugFix|talk]]) 15:39, 13 November 2013 (UTC)

=={{header|Avail}}==

===If-Then-Else===

If someNumber > 5 then [Print: "Too high!";] else [Print: "Adequate amount.";];

else [score := 45;];

===Ternary===

The basic control structures in Avail can be used as expressions by using blocks with a return value. By tradition this distinction is noted by using a lowercase first character.

=={{header|AWK}}==

Conditionals in awk are modelled after C:

For a branch with more than a single statement, this needs braces:

if(i<0) {

i=0; j=1

} else {

i=42; j=2

There is also the ternary conditional:

=={{header|Axe}}==

===Simple===

YEP()

===Inverse If===

NOPE()

===If-Else===

YEP()

Else

NOPE()

Axe has no support for switch-like statements. If-ElseIf-Else structures are required to achieve the same goal.

===If-ElseIf-Else===

NOPE()

ElseIf 1=1

Else

NOPE()

===If-InverseElseIf-Else===

NOPE()

Else!If 1=2

Else

NOPE()

=={{header|Babel}}==

===Simple select===

"foo" "bar" 3 4 > sel <<

Prints "foo" since '3 4 >' evaluates to false, which causes sel to remove "bar" from the stack.

===If-Then-Else===

{3 4 >}

{"foo"}

ifte

<<

Prints "bar" because the first line is the "if", the second line is the "then" and the last line is the "else", and '3 4 >' evaluates to false.

===Conditional===

({3 4 >} {"Three is greater than four" }

{3 3 >} {"Three is greater than three"}

cond

<<

Prints "Three is greater than two", as expected.

BASIC can use the if statement to perform conditional operations:

20 IF A% THEN PRINT "A IS TRUE"

30 WE CAN OF COURSE USE EXPRESSIONS

50 IF NOT(A%) THEN PRINT "A IS FALSE"

60 REM SOME VERSIONS OF BASIC PROVIDE AN ELSE KEYWORD

Here are code snippets from a more modern variant that does not need line numbers:

Single line IF does not require END IF

Multi-line IF:

'do stuff

ELSE IF x = 0 THEN

ELSE

'do more stuff

Like in [[#C|C]], any non-zero value is interpreted as True:

'the number is not 0

ELSE

'the number is 0

===select case===

The condition in each case branch can be one or more constants or variables, a range or an expression.

CASE 1

'do stuff

CASE ELSE

'default case

===Computed ON-GOTO===

or:

20 GOTO v * 100

99 STOP

210 STOP

300 PRINT "Cherry"

===Conditional loops===

Some variants of basic support conditional loops:

20 L=0

30 WHILE L<5

100 PRINT L

110 L=L+1

==={{header|Applesoft BASIC}}===

Applesoft BASIC does not have ELSE, only the IF-THEN structure and computed ON-GOSUB and ON-GOTO

20 IF X THEN PRINT "X IS TRUE"

30 IF NOT X THEN PRINT "X IS FALSE"

100 PRINT "APPLE": RETURN

200 PRINT "BANANA": RETURN

=={{header|BASIC256}}==

</pre>

I think this test shows that nested if statements parse as they do in c.

for i = 0 to 1

for j = 0 to 1

next j

next i

=={{header|Batch File}}==

IF syntax:

IF [NOT] ERRORLEVEL number command

IF [NOT] string1==string2 command

GEQ - greater than or equal

/I case insensitive string compares

The ELSE clause must be on the same line as the command after the IF.

For example:

IF EXIST %filename% (

del %filename%

echo %filename% not found

)

=={{header|BBC BASIC}}==

IF condition% THEN statements ELSE statements

REM ON ... PROC (ELSE clause is optional):

=={{header|beeswax}}==

The 4 conditional operators are:

' lstack top value == 0 ? skip next instruction : don’t skip next instruction.

" lstack top value > 0 ? skip next instruction : don’t skip next instruction.

K lstack top value == 2nd value ? skip next instruction : don’t skip next instruction.

Example:

>`n > 0`d >`m > 0`d >Lp`m > n`;

Example output:

i3

n > 0

Enter integer m:

i0

=={{header|Befunge}}==

These snippets input a number and use the conditional operators to print a "0" if it is zero and an "X" otherwise.

> & |

'''#''' is the skip command.

It unconditionally skips one character, allowing a little flexibility in flow control.

=={{header|blz}}==

===if-else===

if i % 2 == 0

print("even")

print("odd")

end

=={{header|Bori}}==

===if-elif-else===

if (i == 0)

return "zero";

else

return "even";

=={{header|BQN}}==

The basic method of control flow in BQN is implemented using first-class functions and Choose (<code>◶</code>). Using Choose, we can implement some basic control structures:

IfElse ← {c‿T‿F: c◶F‿T@}

While ← {𝕩{𝔽⍟𝔾∘𝔽_𝕣_𝔾∘𝔽⍟𝔾𝕩}𝕨@}´ # While 1‿{... to run forever

Select ← {(⊑𝕩)◶(1↓𝕩)@}

Switch ← {c←⊑𝕩 ⋄ m‿a←<˘⍉∘‿2⥊1↓𝕩 ⋄ (⊑a⊐C)◶m@}

The other method of branching is using function predicates, which can be used in any blocks for an if-else like conditional:

a<b ? a+↩1 ; # If

a<c ? c-↩1 ; # Else If

a-↩2 # Else

However, they act like any other block header, so the variables defined in each predicate segment do not exist in their else and else if condition. Block Headers in general provide a rudimentary form of control flow (checking for exact matches and wildcards), but these are much more constrained than a general conditional.

The following expression writes "That's what I thought." to your screen and evaluates to the expression "Right".

& put$"Strange, must check that Bracmat interpreter."

& 0

| put$"That's what I thought."

=== switch-like branching ===

In the following example, the resulting expression is a single node containing "4".

: ( (<3|>5)

& put$"Not quite, must check that Bracmat interpreter."

& put$"That's what I thought."

)

=={{header|Brainf***}}==

Thus in the following sequence:

The . instruction will be skipped, while the following sequence

will result in an infinite loop. Finally, in the following sequence

The . instruction will be executed once.

Using the ''Choose'' command:

blsq ) 9 2.%{"Odd""Even"}ch

"Odd"

Using the ''If'' command (produce next even number if odd):

blsq ) 9^^2.%{+.}if

10

blsq ) 10^^2.%{+.}if

10

Using the ''IfThenElse'' command (produce next odd number if even or previous even number if odd):

blsq ) 10^^2.%{-.}\/{+.}\/ie

11

blsq ) 9^^2.%{-.}\/{+.}\/ie

8

Emulating Switch-Case behaviour:

blsq ) {"Hate tomatos" "Like Bananas" "Hate Apples"}{"Tomato" "Banana" "Apple"}"Banana"Fi!!

"Like Bananas"

blsq ) {"Hate tomatos" "Like Bananas" "Hate Apples"}{"Tomato" "Banana" "Apple"}"Apple"Fi!!

"Hate Apples"

=={{header|C}}==

===if-elseif-else===

{

// Some Task

{

// Some Task

===Ternary===

===switch===

{

case 1:

// Some task

break;

If fall through algorithms are required use the goto keyword.

{

case 1:

// Some task

break;

=={{header|C++}}==

Selecting a type depending on a compile time condition

template<typename ThenType, typename ElseType> struct ifthenelse<true, ThenType, ElseType>

long int, // in that case, we'll need a long int

int> // otherwise an int will do

=={{header|Clean}}==

There are no ''then'' or ''else'' keyword in Clean.

The second argument of <tt>if</tt> is the then-part, the third argument is the else-part.

===case-of===

42 -> "Correct"

===function alternatives===

===guards===

| x == 42 = True

| otherwise = False

n | n < 0 -> "Not even close"

42 -> "Correct"

=={{header|Clipper}}==

'''if-elseif-else-endif'''

SomeFunc1()

ELSEIF x == 2

ELSE

SomeFunc()

'''do case'''

CASE x == 1

SomeFunc1()

OTHERWISE

SomeFunc()

=={{header|Clojure}}==

===if-then-else===

(if (= 1 2) :yes :no) ; returns :no

===when===

Similar to if, but body in an implicit do block allowing multiple statements.

No facility for providing an else. <code>when</code> is defined as a macro.

(print "hello")

(println " world")

===cond===

The cond macro takes a series of test/result pairs, evaluating each test until one resolves to logical true, then evaluates its result.

Returns nil if none of the tests yield true.

(= 1 2) :no) ; returns nil

(cond

(= 1 2) :no

Since non-nil objects are logical true, by convention the keyword :else is used to yield a default result.

(= 1 2) :no

===condp===

Similar to cond, but useful when each test differs by only one variant.

4 :a ; cond equivalent would be (< 4 3) :a

3 :b

2 :c

Optionally takes a final arg to be used as the default result if none of the tests match.

4 :a

3 :b

===case===

{{Works with|Clojure|1.2}}

0 (println "0")

1 (println "1")

=={{header|CMake}}==

if(num GREATER 100)

message("${num} is small.")

message("We might want a bigger number.")

The if() and elseif() commands evaluate boolean expressions like ''num GREATER 100''; refer to [http://www.cmake.org/cmake/help/cmake-2-8-docs.html#command:if cmake --help-command if].

=={{header|COBOL}}==

===if-then-else===

imperative-statement-1

else

imperative-statement-2

end-if

===evaluate===

when 'good'

good-imperative-statement

when other

default-imperative-statement

=={{header|CoffeeScript}}==

===if-then-else===

if n == 1

console.log "one"

else

console.log "other"

===switch===

switch n

else

console.log "other"

===ternary expressions===

CoffeeScript is very expression-oriented, so you can assign the "result" of an if-then to a variable.

# alternate form

if condition

then "yup"

=={{header|ColdFusion}}==

===if-elseif-else===

'''Compiler:''' [[ColdFusion]] any version

do something

<cfelseif x eq 4>

<cfelse>

do something else

===switch===

'''Compiler:''' [[ColdFusion]] any version

<cfcase value="1">

do something

do something

</cfdefaultcase>

=={{header|Comal}}==

===IF/THEN===

===IF/THEN/ELSE===

PRINT "True"

ELSE