NetRexx at Once

Quick Guide for Java Developers

[Index] [Previous Chapter] [Next Chapter]

4. Control Flow

Here is a strict comparison between control flow constructs in Java and NetRexx.

4.1 DO Instruction

The DO instruction is used to group togheter chuncks of code. You can exit from a DO group with the LEAVE instruction. You can also protect objects, when the enclosed code executes, with the protect keyword (synchronization), catch exceptions and label the end of the group with a name for easy reading. An empty block or a null instruction must be rendered with NOP.

Java
{
  //... list of instructions
}
 NetRexx
do
  --... list of instructions
end
{}
;
 
nop
nop
{
  //... list of instructions
}
 
do label do_name
  --... list of instructions
end do_name

synchronized(object) {
  //... list of instructions
}
 
do protect object
  --... list of instructions
end

try {
  //... list of instructions
} catch(Exception e) {
  //... catch instructions
} finally {
  //... finally instructions
}
 
do
  --... list of instructions
catch e=Exception
  --... catch instructions
finally
  --... finally instructions
end

4.2 IF Instruction

The IF instruction is used (as usual) to conditionally execute group of instructions.

Java
if (expression)
  instruction;
 NetRexx
if expression then
  instruction

if (expression)
  instruction_then;
else
  instruction_else;
 
if expression then
  instruction_then
else 
  instruction_else

if (expression) {
  instructions_then;
} else {
  instructions_else;
}
 
if expression then do
  instructions_then
  end
else do
  instructions_else
  end

4.3 LOOP Instruction

The LOOP instruction is used to execute repeatedly a block of instructions. You can exit a loop with the LEAVE instruction and repeat it before end with ITERATE. A LOOP block may use all the keywords of DO, such as label, protect, catch and finally. You can build very complex loops with repetitors (to-by-for, over, for and forever) and conditions (while and until).

Java
while(true) {
  if(something) break;
  if(something_else) continue;
  // other instructions
}
 NetRexx
loop forever
  if something then leave
  if something_else then iterate
  -- other instructions
end
for(int ct = 0; ct < 10; ct++) {
  // instructions with ct not used
}
 
loop for 10
  -- instructions
end
for(int ct = 0; ct < 10; ct++) {
  // instructions
}
 
loop ct=0 for 10
  -- instructions
end
for(float x=5.1; x<17.2; x+=2.5) {
  // instructions
}
 
loop x=5.1 to 17.2 by 2.5
  -- instructions
end
int ct = 0;
for(float x=20.5; x>2.5; x-=2.0) {
  if(ct++ == 4) break;
  // instructions
}
 
loop x=20.5 to 2.5 by -2.0 for 4
  -- instructions
end
--
--
Hashtable hash = new Hashtable();
hash.put("0","zero");
hash.put("1","one");
hash.put("2","two");
for (
  Enumeration e = hash.elements();
  e.hasMoreElements();
) {
  System.out.println(e.nextElement());
}
 
hash=Hashtable       -- hash =''
hash.put('0','zero') -- hash['0']='zero'
hash.put('1','one')  -- hash['1']='one'
hash.put('2','two')  -- hash['2']='two'
for word over hash
  say word
end
--
-- You can use the class Hastable
-- or alternatively indexed strings
while(expression) {
  // instructions
}
 
loop while expression
  -- instructions
end

do {
  // instructions
} while(!expression);
 
loop until expression
  -- instructions
end

for(float x=0.0; x<9.0; ct+=0.1) {
  if(x < minX) break;
  // instructions
  if(x > maxX) break;
}
 
loop x=0.0 to 9.0 by 0.1
while x>minX until x>maxX
  -- instructions
end x
--
synchronized(anObject) {
  try {
    while(expression) {
      // instructions
    }
  } catch(Exception e) {
      // instructions
  }
}
 
loop protect anObject while expression
  -- instructions
catch e=Exception
  -- instructions
end
--
--
--
--

4.4 SELECT Instruction

The SELECT instruction is used to select one of several execution alternatives. The options are listed with the when keyword. If none of the conditions is fulfilled, the code marked with otherwise is executed. You can exit a selection with the LEAVE instruction. A SELECT block may use all the keywords of DO, such as label, protect, catch and finally.

Java
switch(expression) {
  case 0: break;
  case 1:
    System.out.println("one"); break;
  case 2:
    System.out.println("two"); break;
  default:
    System.out.println("other"); break;
}
 NetRexx
select
  when expression=0 then nop
  when expression=1 then say'one'
  when expression=2 then say'two'
  otherwise say'other'
end
--
--
--
if(condition_1) {
  // instructions_1
} else if(condition_2)
  // instruction_2
else {
  // instructions_else
}
//
//
//
 
select
  when condition_1 then do
    -- instructions_1
    end
  when condition_2 then
    -- instruction_2
  otherwise do
    -- instructions_else
    end
end

4.5 SIGNAL Instruction

Exceptions are thrown with the SIGNAL instruction.

Java
try {
  // instructions
  if(something)
    throw new Exception(
      "something happened"
    )
  ;
  // instructions
} catch(Exception e) {
  System.out.println(e.toString());
}
 NetRexx
do
  -- instructions
  if something then
    signal Exception(
      "something happened"
    )
  -- instructions
catch e=Exception
  say e.toString
end
--

4.6 EXIT Instruction

To stop a program you need to use the EXIT instruction.

Java
if(exit_condition)
  System.exit(0)
;
 NetRexx
if exit_condition then
  exit
--

[Index] [Previous Chapter] [Next Chapter]