report program generator - murray state information...

May 5, 2023

Report Program Generator

Jennifer GrossCSC 415 – DR.WILLIAM LYLE, III

Table of ContentsHistory of Report Program Generator.............................................................................................1

Purpose of Development..............................................................................................................1

FARGO........................................................................................................................................1

RPG’s Competition......................................................................................................................1

RPG II..........................................................................................................................................1

RPG III.........................................................................................................................................2

DE/RPG.......................................................................................................................................2

RPG IV........................................................................................................................................2

RPG Open Access........................................................................................................................3

Overview..........................................................................................................................................3

File Types and Specifications......................................................................................................3

Names, Bindings, and Scopes......................................................................................................5

Data Types...................................................................................................................................6

Expressions and Assignment Statements.....................................................................................7

Statement-Level Control Structures............................................................................................9

Subprograms..............................................................................................................................11

Support for Object-Oriented Programming...............................................................................11

Concurrency...............................................................................................................................11

Exception Handling and Event Handling..................................................................................11

Evaluation of RPG.........................................................................................................................12

Readability.................................................................................................................................12

Writability..................................................................................................................................12

Reliability..................................................................................................................................13

Cost............................................................................................................................................13

Conclusion.................................................................................................................................13

Appendix A....................................................................................................................................14

Appendix B....................................................................................................................................15

Appendix C....................................................................................................................................17

Appendix D....................................................................................................................................18

Bibliography..................................................................................................................................21

History of Report Program GeneratorPurpose of Development

The Report Program Generator (RPG) language was developed by IBM in 1959 and was

originally created for use with punched card machines. As the name of the language implies, the

purpose of the language is the “generation of reports from data files, including matching record

and sub-total reports” (IBM RPG).

FARGO

FARGO, or Fourteen-o-one Automatic Report Generation Operation, was the

predecessor to RPG and was available for use on the IBM 1401, hence its name. Both RPG and

FARGO were created to help ease the transition from the IBM “Tab” unit technicians to the

newer computers. RPG was considered the superior language and quickly replaced FARGO as

the report generating language of the time (IBM RPG).

RPG’s Competition

At this time in history, RPG and FARGO were not the only two languages widely in use.

Other languages include Assembler, COBOL, FORTRAN, ALGOL, PL/I, and Autocoder.

However, Assembler was more business oriented, FORTRAN was more geared towards

mathematics, and the rest were more commonly used for business mainframe operations. This

being said, RPG had little competition on the market with which it had to compete (IBM RPG).

RPG II

RPG II was released in the late 1969 and was available on several different systems (RPG

Language). One of the more notable additions to RPG II that was not present in RPG includes

the ability to handle input and output devices, such as a keyboard or workstation.

As with most languages, RPG II underwent sub-releases of new features to be included in

the language. A few of the more important releases included the additions of the “if equals

(IFEQ)”, “if not equals (IFNE)”, “if greater than (IFGT)”, “if greater than or equal to (IFGE)”,

“if less than (IFLT)”, “if less than or equal to (IFLE)”, and “END” groupings that were added to

the 1970’s release, as well as the “call/parm” that is used to call external subroutines and the

removal of the restriction of having to put “SR” in columns 7 and 8 for internal subroutines

(IBM RPG II).

RPG III

RPG III was released in 1979 and was created specifically for the System/38 as well as

the AS/400. In comparison, RPG III had left a lot of its original identity behind now providing

more modern structured constructs, such as blocked IF-ENDIF statements, DO loops and

subroutines (IBM RPG). Other major features that became available with RPG III was the ability

to use external file descriptions, objects cannot be replaced while in use, a file cannot be moved

unilaterally into production (it must be compiled into the library with the external files), DDS file

types are created and have to be compiled before the program itself is compiled (IBM RPG III).

DE/RPG

DE/RPG, also known as Data Entry RPG, was released in the early 1980s and was

exclusively for the IBM 5280 series. DE/RPG was very similar to RPG III, except it excluded the

DDS file types which had to be included into the RPG source itself (IBM RPG).

RPG IV

RPG IV, also known as RPGLE or ILE RPG, was released in 1994 making the name no

longer an initialism. RPG IV is the only version of RPG supported by IBM. With the release of

OS/400 in 2001, RPG IV was able to offer a “greater freedom for calculations than offered by

the Extended Factor-2 Calculation Specification” (IBM RPG). This freedom was granted by the

“free-format” source entry. The free calculation served as an alternative to the original column

based format that has been required in the past. In other words, the free calculation format

allowed for RPG coding to read similar to the syntax of other mainstream programming

languages. Up until October 2013, the free format entry block only applied to calculation

specifications, however with the V7R1 TR7 upgrade to the language, the “/free” and “/end-free”

calculations were no longer required and the language broke its final ties to punched cards (IBM

RPG).

RPG IV has become a very robust language over the years including various features

over the years. Some of these features include the addition of more built-in functions, the ability

to link directly to Java objects, the ability to write CGI programs, all while maintaining the

majority of its backward compatibility. That is, an RPG program written 30 years can still run

today with very little to no modifications.

While editing is still able to be done from standard green screen, IBM has released the

IDE WebSphere Development Studio, renamed to Rational Development Studio for i, which is a

customized version of Eclipse.

RPG Open Access

Released in 2010 with the full name of Rational Open Access: RPG Edition, was

designed to “remove the necessity for all output from RPG programs to be forced into the limited

5250 data stream”, but to instead be passed to handlers, then wrapped in XML to create a web

page that does not look like a 5250 screen.

OverviewFile Types and Specifications

Since RPG IV is the only version of RPG that is supported by IBM and has the most

robust features, it will be the version that will be focused on.

RPG as a language makes use of a wide variety of file types and specifications including:

physical, logical, program described, externally described, printer, report, and DDS files.

Physical Files versus Logical Files

In RPG a physical file is a file that contains one record format, while a logical file is a file

that does not take up any memory space and does not actually contain any data, but rather loads

it at run time. A logical file can also have up to 32 records formats and cannot exist without the

physical file(s) that it is based on. That being said, a physical file cannot be deleted until all

logical files tied to it are deleted (Difference Between Physical Files and Logical Files).

Program Described versus Externally Described File

A file that is externally described simply means that the file is defined within its own file.

A program described file, on the other hand, has to be defined with the file that is making use of

the other file.

Device and Report Files

Device files include types such as printer files (PRINTER) as well as workstation files

(WRKSTN). Report file types include report files and DDS files. Each of these four file types

require a physical file that defines how the document is to be displayed either on screen or upon

printing (RPG IV Programming on the AS/400).

Specification Blocks

RPG makes use of code blocking to help readability and help differentiate portions of

code. The blocking practice used in RPG is specification blocking, which breaks the code into

three major portions: file/declaration, calculation, and output.

The file/declaration block contains all file specifications as well as all variable

declarations. This block is denoted by the character ‘D’ or ‘F’ in the specification position (RPG

IV Programming on the AS/400). It is important to note that this is the only block that is still

column based in RPG, therefore, it follows a very particular set of rules. An example of the

layout for this block can be found in Appendix A along with a full explanation of each position

representation.

The calculation block contains all the logic of the program. In the past this block was

denoted by the character ‘C’; however, after RPG IV implemented the free-format entry area,

this notation is no longer required (RPG IV Programming on the AS/400). Examples of both the

column based layout as well free-format entries can be found in Appendix A.

The output block is no longer required in an RPG program, nor is it commonly used.

Before the free-format was implemented into RPG IV, the output block was denoted by the

character ‘O’ and contained the code used to direct the printer or screen how to display the data

(RPG IV Programming on the AS/400). Now, the common practice is to have a separate report

file or DDS file containing the specifications and simply calling the separate program to produce

the output. An example of an output block (in column based format) is provided in Appendix A.

Names, Bindings, and Scopes

Names

When considering naming variables there are three major ideas that come to mind for

RPG: case sensitivity, reserved words, and length restriction. Up until RPG IV, case sensitivity

was irrelevant. The way RPG handled characters was such that all characters were capitalized.

RPG IV was the first version to allow mixed uppercase and lowercase characters in variable

names (RPG IV Programming on the AS/400).

Most languages include a list of reserved words that have some form of special

functionality, RPG is no exception. RPG has various types of reserved words including words

that access the job date, are used for page numbering, figurative constants, database file

positioning, indicators, date and time, etc. (RPG IV Words with Special Functions/ Reserved

Words). An extensive list is included in Appendix B.

Since RPG is column based for its declarations, there has always been a limit on how

long variable names could be. Prior to RPG IV maximum length for variable names was only 6

characters and maximum length for file names was only 8 characters. After RPG IV, both

variable names and file names could be a maximum of 10 characters long (RPG IV

Programming on the AS/400).

Binding

Binding is an important aspect of any language. Some languages have dynamic binding,

while others have static binding for variables. RPG IV has static binding (Klement). That is to

say that most of the work of the program takes place at compile time as compared to execution

time. This tends to be a double edged sword since it means that compiling tends to take a little

longer but run time is shorter. For RPG IV, since it is an ILE (integrated language environment)

language, the compilation time is standardly short, it can afford a longer compile time.

Scope

Scoping of how RPG is slightly different than the modern languages. Prior to RPG IV all

variables were globally scope, since they had to be defined in the declaration block. RPG IV,

however, came with the ability to define variables “on-the-fly” inside subprocedures (Cozzi).

Variables defined this way, are locally scoped. This creates a new issue for RPG that it has never

had in the past, how to resolve naming collisions. Naming collisions occur when a locally

defined variable is named the same as either a global variable or a locally defined variable in a

different subprocedure. For the latter, RPG not only allows it, but encourages it and has no

restrictions on it. The variables are viewed as completely distinct. This is not the case with a

naming collision between a local variable and a global variable. A naming collision between a

local and global variable come with many consequences. First, anything outside the

subprocedure will access the globally defined variable, while everything inside the subprocedure

will use the locally defined (Cozzi). However, an issue arises since subroutine names and tag

names are only known to the procedure in which they are defined and all fields are specified on

the input or output specification are considered global variables, when a subprocedure uses the

input or output specification the global name is used even if a local variable is defined

(Procedures and Subprocedures).

Data Types

Primitive Data Types

As previously stated, variables are standardly defined within the declaration block. One

of the columns of the declaration block is the “data type column”. In RPG, each data type

corresponds to a single alphabetical character, i.e. “A” corresponds to an alphanumeric character.

For the full list of data types, their corresponding letter, the length restrictions, as well as a brief

description see Appendix C.

Arrays

In RPG IV there are two types of arrays, runtime arrays and compile time arrays.

Compile time arrays are standardly used to store error messages, while runtime everything else

(Niraj). There are two different ways to declare runtime arrays. The first way is to declare the

array with the keyword “Dim” where you specify the dimension of the array. Another way to

declare an array is to use keyword “EXTNAME(filename)”, where filename is a preexisting

externally described data structure. This format creates an array which mirrors the data structure

(Rational Developer for System i). This is commonly done to store data returned into the array

from a SQL query.

Expressions and Assignment Statements

Placement

RPG is restrictive of where an expression can be placed within the language. Expressions

may be coded only in the following statements: CALLP (call a prototyped procedure or

program), DOU (do until), DOW (do while), EVAL (evaluate expression), EVALR (evaluate

expression with a right adjustment), FOR (for), IF (if), RETURN (return to caller), and WHEN

(when true then select) (Expressions).

General Rules

Not only is RPG restrictive of where an expression can be placed there is also a set of

four general rules that apply to all expressions. First, all expressions are coded in the Extended-

Factor 2 entry on the Calculation Specification or after the operation code on a free-form

calculation. Second, an expression can be continued on more than one specification, when they

are continued the only entries allowed are ‘C’ in column 6 and the Extended-Factor 2 entry. No

special character is required unless the expression is split within a literal or a name. Third, blanks

(in this case parentheses) are required only to resolve ambiguity, but they do enhance readability.

It’s important to note that RPG will read as many characters as possible when parsing tokens of

an expression. Lastly, the TRUNCNBR option does not apply to calculations done within

expressions. If overflow occurs, an exception is always issued (Expressions).

Operators

RPG includes the standard list of expression operators that one would expect to be in a

language including various unary operations, binary operations, built-in functions, and user-

defined functions.

For unary operations, RPG includes the ‘+’, ‘-’, and “NOT”. The unary plus operation is

used to maintain the value of the numeric operand. The unary minus operation is used for

negation of the value of the operand. The logical negation operation returns ‘1’ if the value of the

indicator operand is ‘0’, or returns ‘0’ if the operand is ‘1’ (Expressions).

Binary operations in RPG are coded between the two operands. Binary operations

included are: ‘+’, ‘-’ ‘*’, ‘/’, ‘**’, ‘=’, ‘<>’, ‘>’, ‘>=’, ‘<’, ‘<=’, ‘AND’, ‘OR’. These operations

are represent the meanings standardly associated with them. It is important to note that all logical

operations and equality operations in RPG return indicator values of either ‘1’ or ‘0’

(Expressions).

Built-in functions in RPG are similar to operation codes, such that they perform

operations on the data specified. Built-in functions are denoted by the percent symbol (%) as the

first character (Operations). An example would be %TRIM or %SUBST (substring). For a

complete list, see Appendix D.

Any prototyped procedure, or user-defined function, that returns a value can be used

within an expression. User-defined functions are called in a similar manner as in most languages,

FunctionName(parameter), and do not have any character prefix used for denoting the function

(Expressions).

Precedence

Operator precedence is an important consideration for any language and can result in

unexpected outcomes if precedence is not anticipated. In RPG operator precedence is as follows:

1. ()2. Built-in functions, user-defined functions3. Unary +, unary -, NOT4. **5. *, /6. Binary +, binary –7. Equality operations ( = , <>, >, >=, <, <= )8. AND9. OR

(Expressions).

It can be seen that the relational operations AND and OR are evaluated left to right;

however, it is important to note that as soon as the value is known, the evaluation of the

expression stops and the value is returned. This is to say that not all operands of an expression

have to be evaluated. This is important for short circuit evaluation, which is commonly used in

RPG to allow an array index to be tested as well as used within the same expression, causing the

expression to never result in an array indexing exception (Expressions).

Default Rules and Precision

Default precision rules in RPG is determined by a two-step process. First, the “natural”

precision of the result is computed. Second, if the “natural” precision is greater than 31 digits,

the precision is adjusted to fit in 31 digits.

Statement-Level Control Structures

Selection Statements

In regards to selection statements in programming there are two major types: the select or

case statement, and the if/elseif/else statement. RPG has both of these statements built in. RPG’s

select statement conditionally processes a sequence of relational WHEN statements. Surprisingly

RPG does not require the select statement to include any WHEN operations or an OTHER

operation, it only requires a SELECT operation and an ENDSL operation. RPG’s form of an ‘if’

statement is very straight forward. RPG does allow IF and ELSEIF statements, which not all

languages include, which helps lessen the number of IF statements usually required in a program

(RPG IV Programming on the AS/400).

Iterative Statements

RPG includes three different forms of a ‘do’ loop as well as a ‘for’ loop. There is the

standard DO/ENDDO loop, which is used to control the processing of a group of calculations for

a predetermined number of times. The DOU (do until)/ENDDO loop is a second form of the ‘do’

loop. This loop differs from the DO/ENDDO loop in such that it requires a programmer-supplied

counter to exit from the looping sequence. The third form of the ‘do’ loop is the DOW (do while)

/ENDDO loop. This loop is different in that it is only performed if the logical expression is

initially true, whereas the DOU loop executes at least once. It is similar, however, in the fact that

it too requires a programmer-supplied counter for exiting from the looping sequence (RPG IV

Programming on the AS/400). RPG’s ‘for’ loop is a more complicated iteration statement.

FOR/ENDFOR loops require a starting index, a value to increment by, and end point for

terminating the looping sequence (Structured Programming Operations). The statement itself is

written as:

FOR index-name { = starting-value }{ BY increment-value }{TO|DOWNTO limit-value }

{loop body }

ENDFOR

It is important to note that RPG did have a structured operator built-in to transfer control

immediately a loops ENDDO or ENDFOR statement. This statement is ITER, and ultimately

forces the next iteration of the loop to be executed immediately. There is also the LEAVE

operation. The difference between the LEAVE operation and the ITER operation is that LEAVE

transfers control to the statement after the ENDDO or ENDFOR operation (Structured

Programming Operations).

Unconditional Branching and Other Structured Operations

Traditionally RPG had several IF/ELSE formats specifically for use with equality

operators. In RPG IFxx/ELSE/ENDIF statements existed, where xx could be equivalent to EQ

(equal to), GE (greater than or equal to), GT (greater than), LE (less than or equal to), LT (less

than), or NE (not equal to). These codes were also used in DOU and DOW. With free-format

entry, however, these codes are not used any more rather the symbolic representation is used

(RPG IV Programming on the AS/400).

Another structured operator that used to be used was the COMP operation. Historically

this function was used to compare two values then use an indicator value to represent the result.

As stated, this has since been discontinued as a practice due to it being unstructured and should

not be used in present day code (RPG IV Programming on the AS/400).

The GOTO operation is another operation that was used in the past in RPG. This also is

an operation that should not be used in present day code since it is also unstructured. The use of

GOTO operations was used to pass control to other portions of code. This practice created what

is referred to as “spaghetti code” and is very difficult to follow. This operation is one form of

unconditional branching that RPG included. The other form of unconditional branching was the

CABxx (compare and branch) operation. Again the xx could be equivalent to any of the equality

statements aforementioned. This is again another operation that should not be used in present day

code since it is unstructured (RPG IV Programming on the AS/400).

Subprograms

RPG has two versions of subprograms: procedures and functions. Procedures in RPG are

referred to as subroutines. Each subroutine must being with a BEGSR tag and end with an

ENDSR tag with the body of the routine in the middle. Functions in RPG come in two forms,

built-in functions and user-defined functions. These two forms were both discussed previously

with operators.

Support for Object-Oriented Programming

Currently the concept of object-oriented programming in RPG is purely theoretical. There

has been discussion of how to simulate the idea. The leading idea currently is to use a separate

service program per file and pass the operation and dynamically allocated pointers as parameters.

The service program would have to include all the functionality for handling the pointer as well

as the data. As an example basic functions would include a file write function, a get function,

next and previous functions to handle records, even new and free functions for allocating storage

and handling the pointer (Can RPGLE simulate OO programming?). Again, this idea is currently

purely theoretical due to how involved developing such a system would be.

Concurrency

RPG has a built-in method for handling concurrency. THREAD(*CONCURRENT) is

specified to allow multiple threads to run in the module at the same time. By default, the static

storage will be thread-local when using this method. RPG does give programmers the option to

have some static variables shared among threads by using the STATIC(*ALLTHREAD)

keyword. Another method is to use THREAD(*SERIALIZE). Using this makes all access to the

procedures serialized. When in a multithreaded environment the code can be used by at most one

thread at any given time (THREAD(*CONCURRENT | *SERIALIZE)).

Exception Handling and Event Handling

RPG IV provides four types of exception handling mechanisms:

1. An error indicator or an ‘E’ operation code extender handler2. A MONITOR group3. An error subroutine handler4. A default exception handler

RPG categorizes exceptions into two classes: program and file. Which type of error

subroutine is determined based on the class or error. An example of a program error would be

division by zero or SQRT (square root) of a negative number, while a file error would be a

device error or undefined record type.

Evaluation of RPGOverall for the age of the language RPG has evolved to include the majority of the

present day necessities of a language; however, to thoroughly evaluate the language the focus

will be on the most robust version of RPG, RPGIV, and will be critiqued on four standards:

readability, writability, reliability, and cost.

Readability

In terms of readability RPG has come a long way leaving behind the column based

structure it had in the past for a free-format entry style. The syntax of the code closely resembles

English making it easy to digest and understand without any prior knowledge of the language.

The inclusion of end tags on all forms of structures (i.e. ENDDO, ENDFOR, ENDSR, etc.)

enhances the readability by making it easy to tell exactly what is being ended. A downside to

RPG is the limitation of the length of variable names; however, common practice within a

company or even the individual, can make the use of only 10 characters more than enough to

create a meaningful variable name.

Writability

Again, the process of writing RPG has greatly improved with the implementation of free-

format entry in RPG IV. Not having to memorize what each column stands for has made it a

much simpler process. Now, the process of writing RPG is very straight forward and mirrors a

lot of common day practices. There is a double-edged sword with the process of writing RPG.

There is only one IDE available for writing RPG, Rational Developer Studio. The lack of options

can make it difficult to be completely comfortable programming in an environment.

Nevertheless, the fact that there is only one creates a common ground for all programming in the

language. Also the fact that IBM is the support structure behind the IDE certainly does not hurt.

Reliability

The fact that RPG is still in use is a testament to the reliability of the language. Also, the

lack of additional code or changes need to make past versions of RPG run in RPG IV. The ease

of use for its original purpose is a testament to RPGs design and reliability. Very few of the older

programming languages, especially the specialized languages have had the success in their field

as RPG has. This success can be attributed to RPGs simple formatting as well as its readability

and writability.

Cost

The upfront cost associated with programming in RPG is pretty standard. After paying

for the software license for the IDE and development tools (~$900 per license including support)

and the iSeries hardware, the cost is very minimal. Even though RPG is not a standard language

being taught anymore, due to its readability and writability it is very easy to pick up and does not

require any extensive specialized training. The only major cost remaining is the cost of tapes for

backing-up historical data. Again, most of these costs are standard costs associated with

developing in any language, making RPG IV a reasonably cost language to use and develop in.

Conclusion

Even with the age of RPG, the above information demonstrates just how efficient and

effective of a language it is still in the programming world. Regardless of RPG not included all

of the latest features that the more modern languages have, RPG still does the one thing it was

originally intended to do and does it well. It is fairly safe to say that RPG will always be one of

the leading, if not the leading, programming language for this purpose.

Report Program Generator 18

Appendix A


Appendix B

Words with Special Functions/Reserved Words

The following reserved words allow you to access the job date, or a portion of it, to be used in the program: UDATE *DATE UMONTH *MONTH UYEAR *YEAR UDAY *DAY

The following reserved words can be used for numbering the pages of a report, for record sequence numbering, or to sequentially number output fields:

PAGE PAGE1-PAGE7

Figurative constants are implied literals that allow specifications without referring to length: *BLANK/*BLANKS *ZERO/*ZEROS *HIVAL *LOVAL *NULL *ON *OFF *ALLX'x1..' *ALLG'oK1K2i' *ALL'X..'

The following reserved words are used for positioning database files. *START positions to beginning of file and *END positions to end of file.

*END *START

The following reserved words allow RPG IV indicators to be referred to as data: *IN *INxx

The following are special words used with date and time: *CDMY *CMDY *CYMD *DMY *EUR *HMS *ISO *JIS


*JOB *JOBRUN *JUL *LONGJUL *MDY *SYS *USA *YMD

The following are special words used with translation: *ALTSEQ *EQUATE *FILE *FTRANS

*PLACE allows repetitive placement of fields in an output record*ALL allows all fields that are defined for an externally described file to be written on output.

The following are special words used within expressions: AND NOT OR

Note: NOT can only be used within expressions. It cannot be used as a name anywhere in the source.

The following are special words used with parameter passing: *NOPASS *OMIT *RIGHTADJ *STRING *VARSIZE


Appendix C

Data Types

Data type Name Length Description

A Alphanumeric character

1 to 16,773,104 bytes (fixed)1 to 16,773,100 bytes (varying-length)

Alphanumeric character

B Binary numeric

1 byte (8-bit)2 byte (16-bit)4 bytes (32-bit)8 bytes (64-bit)

Signed binary integer

C UCS-2 character

1 to 8,386,552 characters (fixed)1 to 8,386,550 characters (varying)

16-bit UCS-2 character (DBCS or EGCS)

D Date 10 bytes Date: year, month, day

F Floating point numeric 4 bytes (32-bit)8 bytes (64-bit)

Signed binary floating-point real

G Graphic character

1 to 8,386,552 characters (fixed)1 to 8,386,550 characters (varying)

16-bit graphic character (DBCS or EGCS)

I Integer numeric

1 byte (8-bit)2 bytes (16-bit)4 bytes (32-bit)8 bytes (64-bit)

Signed binary integer

N Character Indicator 1 byte '1' = TRUE'0' = FALSE

O Object Size Undisclosed Object Reference

P Packed decimal numeric

1 to 63 digits,2 digits per byte plus sign

Signed fixed-point decimal number with integer and fraction digits

S Zoned decimal numeric 1 to 63 digits,1 digit per byte

Signed fixed-point decimal number with integer and fraction digits

T Time 8 bytes Time: hour, minute, second

U Integer numeric

1 byte (8-bit)2 bytes (16-bit)4 bytes (32-bit)8 bytes (64-bit)

Unsigned binary integer

Z Timestamp 26 bytes

Date and time: year, month, day, hour, minute, second, microseconds


Appendix D

Built-In Functions

Name Arguments Value Returned %ABS numeric expression absolute value of expression %ADDR variable name address of variable %ALLOC number of bytes to allocate pointer to allocated storage %CHAR graphic, UCS-2, numeric, date, time, or

timestamp expression {: date, time, or timestamp format}

value in character format

%CHECK comparator string:string to be checked{:start position}

first position of a character that is not in the comparator string, or zero if not found

%CHECKR comparator string:string to be checked{:start position}

last position of a character that is not in the comparator string, or zero if not found

%DATE {value {: date format}} the date that corresponds to the specified value, or the current system date if none is specified

%DAYS number of days number of days as a duration %DEC numeric expression {:digits:decpos} value in packed numeric format %DECH numeric expression :digits:decpos half-adjusted value in packed numeric

format %DECPOS numeric expression number of decimal digits %DIFF date or time expression: date or time

expression: unit difference between the two dates, times, or timestamps in the specified unit

%DIV dividend: divisor the quotient from the division of the two arguments

%EDITC non-float numeric expression:edit code {:*CURSYM | *ASTFILL | currency symbol}

string representing edited value

%EDITFLT numeric expression character external display representation of float

%EDITW non-float numeric expression:edit word string representing edited value %ELEM array, table, or multiple occurrence data

structure name number of elements or occurrences

%EOF {file name} '1' if the most recent file input operation or write to a subfile (for a particular file, if specified) ended in an end-of-file or beginning-of-file condition '0' otherwise

%EQUAL {file name} '1' if the most recent SETLL (for a particular file, if specified) or LOOKUP operation found an exact match '0' otherwise

%ERROR '1' if the most recent operation code with extender 'E' specified resulted in an error


'0' otherwise %FLOAT numeric expression value in float format %FOUND {file name} '1' if the most recent relevant operation (for

a particular file, if specified) found a record (CHAIN, DELETE, SETGT, SETLL), an element (LOOKUP), or a match (CHECK, CHECKR, SCAN) '0' otherwise

%GRAPH character, graphic, or UCS-2 expression value in graphic format %HOURS number of hours number of hours as a duration %INT numeric expression value in integer format %INTH numeric expression half-adjusted value in integer format %LEN any expression length in digits or characters %LOOKUPxx argument: array{:start index {:number of

elements}} array index of the matching element

%MINUTES number of minutes number of minutes as a duration %MONTHS number of months number of months as a duration %MSECONDS number of microseconds number of microseconds as a duration %NULLIND null-capable field name value in indicator format representing the

null indicator setting for the null-capable field

%OCCUR multiple-occurrence data structure name current occurrence of the multiple-occurrence data structure

%OPEN file name '1' if the specified file is open '0' if the specified file is closed

%PADDR procedure or prototype name address of procedure or prototype %PARMS none number of parameters passed to procedure %REALLOC pointer: numeric expression pointer to allocated storage %REM dividend: divisor the remainder from the division of the two

arguments %REPLACE replacement string: source string {:start

position {:source length to replace}} string produced by inserting replacement string into source string, starting at start position and replacing the specified number of characters

%SCAN search argument:string to be searched{:start position}

first position of search argument in string or zero if not found

%SECONDS number of seconds number of seconds as a duration %SHTDN '1' if the system operator has requested

shutdown '0' otherwise

%SIZE variable, array, or literal {:* ALL} size of variable or literal %SQRT numeric value square root of the numeric value %STATUS {file name} 0 if no program or file error occurred since

the most recent operation code with extender 'E' specified most recent value set for any program or file


status, if an error occurred if a file is specified, the value returned is the most recent status for that file

%STR pointer{:maximum length} characters addressed by pointer argument up to but not including the first x'00'

%SUBDT date or time expression: unit an unsigned numeric value that contains the specified portion of the date or time value

%SUBST string:start{:length} substring %THIS the class instance of the native method %TIME {value {: time format}} the time that corresponds to the specified

value, or the current system time if none is specified

%TIMESTAMP {(value {: timestamp format})} the timestamp that corresponds to the specified value, or the current system timestamp if none is specified

%TLOOKUPxx argument: search table {: alternate table} '*ON' if there is a match '*OFF' otherwise

%TRIM string string with left and right blanks trimmed %TRIML string string with left blanks trimmed %TRIMR string string with right blanks trimmed %UCS2 character, graphic, or UCS-2 expression value in UCS-2 format %UNS numeric expression value in unsigned format %UNSH numeric expression half-adjusted value in unsigned format %XFOOT array expression sum of the elements %XLATE from-characters: to-characters: string {:

start position} the string with from-characters replaced by to-characters

%YEARS number of years number of years as a duration


Bibliography

Myers, Stanley E. RPG IV Programming on the AS/400. Upper Saddle River: Prentice-Hall, Inc, 1998. 41-49, 130-160. Book. 19 October 2014.

"Can RPGLE simulate OO programming?" 18 February 2000. Midrange. Web. 19 October 2014. <http://archive.midrange.com/rpg400-l/200002/msg00811.html>.

Cozzi, Robert. "Variable Scope: Global vs Local Variables." 15 November 2005. McPress Online. Web. 19 October 2014. <http://www.mcpressonline.com/rpg/variable-scope-global-vs-local-variables.html>.

Difference Between Physical Files and Logical Files. n.d. Web. 19 October 2014. <http://www.go4as400.com/Source-physical-file-and-logical-file-in-as400/files.aspx?cid=666>.

"Expressions." n.d. WebSphere(R) Development Studio ILE RPG Reference. Web. 19 October 2014. <https://publib.boulder.ibm.com/iseries/v5r2/ic2924/books/c092508428.htm>.

"IBM RPG." 2 August 2014. Wikipedia. Web. 4 October 2014.

"IBM RPG II." 1 October 2014. Wikipedia. Web. 4 October 2014.

"IBM RPG III." 17 January 2011. Wikipedia. Web. 4 October 2014.

Klement, Scott. "Difference between Static Binding and Dynamic Binding." 22 September 1999. Midrange. Web. 19 October 2014. <http://archive.midrange.com/rpg400-l/199909/msg00409.html>.

Niraj. "Arrays in ILE RPG." 31 July 2012. Let's AS400. Web. 19 October 2014. <http://www.letsas400.com/ile_rpg_iv/rpgle_run_time_compile_time_arrays>.

"Operations." n.d. WebSphere(R) Development Studio ILE RPG Reference. Web. 19 October 2014. <https://publib.boulder.ibm.com/iseries/v5r2/ic2924/books/c092508427.htm#HDRBIFSINT>.

"Procedures and Subprocedures." n.d. WebSphere(R) Development Studio ILE RPG Reference. Web. 19 October 2014. <https://publib.boulder.ibm.com/iseries/v5r2/ic2924/books/c092508410.htm#HDRHSUBPRC>.

Rational Developer for System i. "Loading a Run-Time Array." n.d. ILE RPG Language Reference. IBM. Web. 29 October 2014. <http://publib.boulder.ibm.com/infocenter/iadthelp/v7r1/index.jsp?topic=/com.ibm.etools.iseries.langref.doc/c0925086157.htm>.


"RPG IV Words with Special Functions/ Reserved Words." n.d. ILE RPG Reference. Web. 19 October 2014. <https://publib.boulder.ibm.com/iseries/v5r1/ic2924/books/c092508325.htm>.

"RPG Language." 24 February 2013. C2. Web. 4 October 2014.

"Structured Programming Operations." n.d. ILE RPG Reference. Web. 19 October 2014. <http://publib.boulder.ibm.com/iseries/v5r2/ic2924/books/c0925083523.htm#HDRSTRUPRO>.

"THREAD(*CONCURRENT | *SERIALIZE)." n.d. ILE RPG Language Reference. Web. 19 October 2014. <http://publib.boulder.ibm.com/infocenter/iadthelp/v7r5/index.jsp?topic=/com.ibm.etools.iseries.langref.doc/c0925086289.htm>.

report program generator - murray state information...

Documents