Basic Syntax Structure in Free Format RPG

 

Introduction

With the advent of free format RPG, the structure and syntax of the language have become far more intuitive and developer-friendly. No longer confined by the fixed columnar format of earlier RPG versions, free format allows programmers to write code in a modern, clean, and flexible style. This flexibility makes the language easier to learn, more readable, and more efficient in enterprise-level development on IBM i (AS/400).

In this article, we will cover the basic syntax structure in free format RPG, including:

• Control options (ctl-opt)
• Declaration specifications (dcl-s, dcl-c, dcl-f, dcl-pr, dcl-pi)
• Operators and expressions
• Flow control structures (if, select, loops, etc.)
• Procedures and subprocedures
• Comments and best practices for readability

By the end of this article, you will understand how free format RPG is structured and how to write clean, maintainable code.

---

1. Control Options (ctl-opt)

Control options in free format RPG are used to define global settings for the program. These settings apply to the entire RPG module and influence how the program behaves during compilation and execution. In older RPG versions, these were specified using header specifications (H-specs). However, in free format, the control options are declared with the ctl-opt keyword.

Common Control Options:

• dftactgrp(*no): Disables the default activation group.
• actgrp(*new): Specifies a new activation group for the program.
• main(): Defines the entry point of the program.
• debug(*yes): Enables debug options.
• bnddir(): Specifies a binding directory for external procedures or service programs.

Example:

ctl-opt dftactgrp(*no) actgrp(*new) main(mainProc);

This example defines that the program will not use the default activation group, creates a new one, and specifies mainProc as the entry procedure of the program.

---

2. Declaration Specifications

Declarations are a critical part of any RPG program. They define variables, constants, files, procedures, and prototypes. In free format, declaration statements no longer need to adhere to column restrictions, and they are more expressive and readable.

2.1 Declaring Variables (dcl-s)

Variables in free format RPG are declared using the dcl-s (declare scalar) keyword, followed by the variable name, its data type, and optional initialization.

Example:

dcl-s customerName char(50);
dcl-s totalAmount packed(9:2) inz(0);   // Initialized to 0
dcl-s taxRate packed(5:2) inz(0.07);    // Initialized to 7%

Here, we declare:

• customerName: A character string of length 50.
• totalAmount: A packed decimal with 9 digits, 2 decimal places, initialized to 0.
• taxRate: A packed decimal with 5 digits, 2 decimal places, initialized to 0.07.

2.2 Declaring Constants (dcl-c)

Constants are defined using the dcl-c (declare constant) keyword. Constants, once defined, cannot be changed during the execution of the program.

Example:

dcl-c PiValue float(8) value(3.1415926535);
dcl-c Message char(20) value('Welcome to RPG!');

In this example:

• PiValue: A constant holding the value of Pi.
• Message: A constant string initialized with the text "Welcome to RPG!".

2.3 Declaring Files (dcl-f)

Files (both input and output) are declared using the dcl-f (declare file) keyword. File declarations specify the access method (*input, *output, *update, etc.), and the file type (e.g., DISK, PRINTER, WORKSTN).

Example:

dcl-f CustomerFile usage(*input) keyed;
dcl-f ReportFile printer oflind(*inof);

• CustomerFile: Declares a file for input with keyed access (e.g., an index for direct access to records).
• ReportFile: Declares a printer file used to generate reports, with an overflow indicator (*inof).

2.4 Declaring Prototypes (dcl-pr and dcl-pi)

Prototypes allow you to declare procedures that may be external or internal to the program. Prototypes help define the signature of a procedure—what parameters it takes and what value it returns.

• dcl-pr: Declare procedure prototype.
• dcl-pi: Declare procedure interface (the actual procedure).

Example:

// Procedure prototype
dcl-pr CalculateTotalAmount packed(9:2);
   baseAmount packed(9:2);
   taxAmount packed(9:2);
end-pr;

// Procedure interface
dcl-pi CalculateTotalAmount packed(9:2);
   baseAmount packed(9:2);
   taxAmount packed(9:2);
end-pi;

In this example, we declare:

• CalculateTotalAmount: A procedure that takes two packed decimal parameters (baseAmount and taxAmount) and returns a packed decimal with 9 digits and 2 decimal places.

---

3. Operators and Expressions

Free format RPG supports various operators to perform calculations, comparisons, and logical operations.

3.1 Arithmetic Operators:

• +: Addition
• -: Subtraction
• *: Multiplication
• /: Division

Example:

totalAmount = baseAmount + (baseAmount * taxRate);

This expression calculates the total amount by adding the tax to the base amount.

3.2 Comparison Operators:

• =: Equal to
• <>: Not equal to
• >, <: Greater than, less than
• >=, <=: Greater than or equal to, less than or equal to

Example:

if totalAmount > 1000;
   dsply 'Large order';
endif;

Here, the program checks if totalAmount is greater than 1000, and if so, displays a message.

3.3 Logical Operators:

• and: Logical AND
• or: Logical OR
• not: Logical NOT

Example:

if isMember and hasDiscount;
   discountAmount = totalAmount * discountRate;
endif;

This example calculates a discount only if both conditions—isMember and hasDiscount—are true.

---

4. Flow Control Structures

4.1 Conditional Statements: if, elseif, else

Conditional logic allows the program to make decisions based on conditions.

Example:

if orderValue > 1000;
   dsply 'High-value order';
elseif orderValue > 500;
   dsply 'Medium-value order';
else;
   dsply 'Low-value order';
endif;

The if block checks conditions in sequence and executes the appropriate block of code.

4.2 select / when

The select / when structure allows for multi-condition checks similar to a switch-case in other languages.

Example:

select;
   when orderType = 'A';
      dsply 'Type A order';
   when orderType = 'B';
      dsply 'Type B order';
   other;
      dsply 'Unknown order type';
endselect;

Here, select provides a way to handle different cases based on the value of orderType.

4.3 Loops: for, dow, dou

Loops allow for repetitive execution of code until a condition is met.

for Loop Example:

for counter = 1 to 10;
   dsply counter;
endfor;

This loop runs from 1 to 10, displaying each value of counter.

dow (Do While) Example:

dow totalSales < targetSales;
   totalSales += dailySales;
enddo;

The loop continues as long as totalSales is less than targetSales.

dou (Do Until) Example:

dou totalSales >= targetSales;
   totalSales += dailySales;
enddo;

This loop runs until totalSales reaches or exceeds targetSales.

---

5. Procedures and Subprocedures

Procedures allow for modular programming by separating logic into reusable blocks of code.

Defining a Procedure:

dcl-proc CalculateDiscount;
   dcl-pi *n packed(9:2);
      baseAmount packed(9:2);
      discountRate packed(5:2);
   end-pi;

   return baseAmount * discountRate;
end-proc;

Here, CalculateDiscount is a procedure that calculates the discount based on the base amount and the discount rate.

Calling a Procedure:

discount = CalculateDiscount(totalAmount : discountRate);

Procedures improve code organization and reusability.

---

6. Comments and Best Practices

Comments are essential for making the code readable and understandable by other developers or for future reference. In free format RPG, comments start with two slashes (//).

Example:

// Calculate total amount with tax
totalAmount = baseAmount * (1 + taxRate);

Best Practices:

• Use meaningful variable names: Variables like totalAmount and baseAmount convey their purpose clearly.
• Break complex logic into procedures: Modularize your code using procedures and subprocedures.
• Comment your code: Ensure that key logic is explained for readability and maintainability.

---

Conclusion

The basic syntax structure of free format RPG is clean, flexible, and modern, allowing developers to focus on business logic rather than syntax constraints. Understanding the basic components like control options, declarations, operators, and flow control structures is the foundation for mastering RPG in its free format style.

As you progress, you will see how this syntax forms the backbone of more complex applications and enterprise solutions on IBM i.