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 to0.taxRate: A packed decimal with 5 digits, 2 decimal places, initialized to0.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 (baseAmountandtaxAmount) 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 ANDor: Logical ORnot: 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
totalAmountandbaseAmountconvey 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.
.png)
.png)