Score Card for RPGLE Programming

Here’s a self-assessment score card that will provide insight into your knowledge of ILE RPG. Many of the skills listed here require knowledge of newer or more advanced ILE RPG language features and are essential to incorporating contemporary "best practices" into your development work.

Each entry below asks you to rate your knowledge of a particular ILE RPG feature.

This self-assessment isn’t intended as a comprehensive test of essential RPG programming skills, such as declaring and using files. Most RPG language features for core programming tasks, such as file I/O, have been around a long time, many dating back even to RPG III on the S/38. Essentially, the self-assessment here is meant to provide a measure of how well you’re keeping up with more recent ILE RPG programming skills that can help you write better-structured, more flexible, and more reliable programs.

For each of the ILE RPG features listed, rate your knowledge using the following scale:

0 — Know very little about why or how to use the feature

1 — Have some idea what the feature does, but not sure how to use it

2 — Have enough basic understanding to use the feature in limited ways

3 — Have a full understanding of when and how to use the feature

When you’ve completed the inventory, you sum your individual ratings to see how you stand.

Control (H) Specifications

You can use H-specs to control a variety of important compilation options. In many cases, an H-spec keyword is equivalent to a parameter you can specify on the CrtBndRpg and CrtRpgMod commands.

Several H-spec keywords are covered in other sections of the assessment. This section includes useful keywords that don’t fit neatly elsewhere.

Rate your knowledge about the following H-spec keywords, and give a brief summary of your understanding:

1.      ActGrp and DftActGrp    2

When an OS/400 job is started, the system creates two activation groups to be used by all other OPM programs. The default activation groups use single-level store for static program variables. You cannot delete the OPM default activation groups. They are deleted by the system when your job ends.

Note: APIs cannot be used if DFTACTGRP(*YES) is specified on the CRTBNDRPG CL command. ILE static binding is not available when a program is created with DFTACTGRP(*YES). This means that your program cannot contain a CALLB operation. DFTACTGRP(*YES) specified, the RCLRSC command frees static storage.

The Reclaim Activation Group (RCLACTGRP) command can be used to delete a

nondefault activation group that is not in use.

2. NoMain                               2

There is no PEP, and therefore much of the tasks done at program start-up, including the loading of the logic cycle, are not done. This lightens the object significantly. It also means that in addition to the service program not being able to be called directly, the modules can't be called, either. The only way to access the service program is through the subprocedures. The module becomes little more than a container for its subprocedures.

NOMAIN modules cannot be called directly. Instead, the subprocedures contained inside the module are called using prototyped call (CALLP in RPG).

3. Optimize     3

Generally, if a module has creation data, you can change the level at which the source code is optimized to run on the system. Processing shortcuts are translated into machine code, allowing the procedures in the module to run more efficiently.

The higher the optimization level, the more efficiently the procedures in the module run. However, with more optimization you cannot change variables and may not be able to view the actual value of a variable during debugging. When you are debugging, set the optimization level to 10 (*NONE). This provides the lowest level of performance for the procedures in the module but allows you to accurately display and change variables. After you have completed your debugging, set the optimization level to 30 (*FULL) or 40. This provides the highest level of performance for the procedures in the module. The system looks for processing shortcuts that reduce the amount of system resources necessary to produce the same output. The higher the optimization level, the more efficiently the procedures in the module run.

4. Option( *NoExpDds )        3

Do not show the expansion of externally described files in the listing or display key field information.

                       

5. UsrPrf         3

                        USRPRF

Specifies the user profile that will run the created program object. The profile of the program owner or the program user is used to run the program and to control which objects can be used by the program (including the authority the program has for each object). This parameter is not updated if the program already exists. To change its value, you must delete the program and recompile using the new value (or, if the constituent *MODULE objects exist, you may choose to invoke the CRTPGM command).

*USER

The program runs under the user profile of the program’s user.

*OWNER

The program runs under the user profile of both the program’s user and owner. The collective set of object authority in both user profiles are used to find and access objects while the program is running. Any objects created during the program are owned by the program’s user.

File (F) Specifications and Database Operations

Externally described files have been around since the first S/38 shipped. They’re a core OS/400 feature that a competent RPG programmer must master. But several features that have been around for a while (e.g., user-controlled opens and transaction support) aren’t yet as widely used as they should be. And a few newer features, such as specifying which library, file, and or member should be opened, belong in every programmer’s arsenal.

Rate your knowledge about the following F-spec keywords, and give a brief summary of your understanding:

6. Commit       3

                        Ensure one of two outcomes for the file operations:

a)       All of the file operations are successful (a commit operation)

b)       None of the file operations has any effect (a rollback operation).

In this way, you process a group of operations as a unit.                    

7. ExtFile and ExtMbr            3

                        Controls which external file/member is used when a file is opened.

Specifies which file/member is opened. The value can be a literal or a variable.

The default file name is the name specified in position 7 of the file specification. The default library is *LIBL.

The default is *FIRST for member

FACCLG01   UF A E           K DISK    RENAME(FORMAT1:FORMAT_X)

FACCLG02   UF A E           K DISK    RENAME(FORMAT1:FORMAT_Y)

V5R1

FFile1     if   e             Disk    Extfile(FilNam) ExtMbr(Member Name)

8. IndDs          3

Associate a data structure name with the INDARA indicators for a workstation or printer file. This data structure contains the conditioning and response indicators passed to and from data management for the file, and is called an indicator data structure. By default, the indicator data structure is initialized to all zeros (’0’s).

9. UsrOpn       3

                        The USROPN keyword causes the file not to be opened at program initialization.

This gives the programmer control of the file’s first open. The file must be explicitly opened using the OPEN operation in the calculation specifications.   

Rate your knowledge about the following D-spec keywords, and give a brief summary of your understanding:

10. Using LikeDs(…: *Key) and LikeRec(…: *Key) to declare a key data structure. 2

The LIKEDS keyword is used to define a data structure, prototyped return value, or prototyped parameter like another data structure. The subfields of the new item will be identical to the subfields of the other data structure. The LIKEREC keyword is used to define a data structure subfield like a record. The subfields of the data structure will be the same as the fields in the record.

The *Key definition will indicate that the Data structure can be used in a keyed specification example %KDS()

Rate your knowledge about the following database I/O operation features, and give a brief summary of your understanding:

11. Open and Close operations           3

Open file operations result in the creation of a temporary resource that is called an open data path (ODP). You can start the open function by using

HLL open verbs, the Open Query File (OPNQRYF) command, or the Open

Data Base File (OPNDBF) command. The ODP is scoped to the activation group of the program that opened the file. For OPM or ILE programs that run in the default activation group, the ODP is scoped to the call-level number. To change the scoping of HLL open verbs, you can use an override. You can specify scoping by using the open scope (OPNSCOPE) parameter on all override commands, the OPNDBF command, and the OPNQRYF command.

The system automatically closes any files scoped to the activation group when the activation group ends. This includes any database files scoped to the activation group opened under commitment control. The close operation for any such file occurs before any implicit commit operation that is performed for the commitment definition at the activation-group level. Therefore, any records that reside in an I/O buffer are first forced to the database before any implicit commit operation is performed.

12. Using %KDS function or free-form key list in a keyed I/O operation 2

                        Used to do the search in a keyed defined data structure where *Key was defined.

Allowed as the search argument for any keyed Input/Output operation (CHAIN, DELETE, READE, READPE, SETGT, SETLL) coded in a free-form group.

A..........T.Name++++++RLen++TDpB......Functions++++++++++++++++++

A          R CUSTR

A            NAME         100A

A            ZIP           10A

A            ADDR         100A

A          K NAME

A          K ZIP

FFilename++IPEASF.....L.....A.Device+.Keywords+++++++++++++++++++

Fcustfile  if   e           k disk    rename(CUSTR:custRec)

DName+++++++++++ETDsFrom+++To/L+++IDc.Keywords+++++++++++

D custRecKeys     ds                  likerec(custRec : *key)

 ...

 /free

         // custRecKeys is a qualified data structure

         custRecKeys.name = customer;

         custRecKeys.zip = zipcode;

         // the *KEY data structure is used as the search argument for CHAIN

         chain %kds(custRecKeys) custRec;

 /end-free

13. Using %Fields function in an Update operation 2

            Only the fields in the %Fields argument list will be updated of the record.

/free

                 chain empno record;

                salary = salary + 2000;

                status = STATEXEMPT;

                update record %fields(salary:status);

 /end-free

14. *Start and *End special values for SetLL operation        2

The *Start and *End keyword are used to set the reading pointer in a file. By using the SETLL the *Start the pointer is set to read the first record and *End will reach end of file. By using *End one can use the read prior opcode to read the last record.

SETLL *Start Recid;

SETLL *End Recid;

Rate your knowledge about the following transaction support features, and give a brief summary of your understanding:

15. Commit and Rollbk operations     3

The COMMIT operation tells the system that you have completed a group of changes to the files under commitment control. The ROLBK operation eliminates the current group of changes to the files under commitment control.

Definition (D) Specifications: General Features

If you’re still programming with D-specs as they existed several years ago, it’s time to crack the books and get familiar with newer features.

This section focuses on features common to different kinds of variable declarations. The Procedure

Definition section covers parameter declarations. Several other sections include additional D-spec features, as well.

Rate your knowledge about declaring and using the following types of variables, and give a brief summary of your understanding:

16. Variables with long names (i.e., greater than fourteen characters)           2

                        DMyVaryLongVariableName1234568...

D                         s                          10 A

The field name has to have 3 dots behind it to indicate the definition will overflow onto the next line.

17. Mnemonics (named constants)     3

A constant field is defined with type “C” and is assigned a value within the definition       

DConstantVariable            c                  'abcdef'

18. Variable-length character variables           3

The variable in memory, will vary during runtime. So when using the variable, the program must state the max length or size of the variable. Used where some character value might be short, long, or not used all the time to save system resources.

DMyVarCharVariable                       100 A     (*varsize)

19. Boolean (indicator) variables        3

Indicators has a two-character name (for example, LR, 01, H3), and is referred to in some entries of some specifications just by the two-character name and in others by the special name *INxx where xx is the two-character nam and can contain only 0 or 1, true or false.       

20. Data structures with qualified subfield names     3

Qualified data structure names allow you to refer to the subfields (Field1/2) of a data structure by qualifying them to the data structure name itself (struct). 

Dstruct                DS

D  Field1                    20 A

D  Field2                    20 A

Rate your knowledge about the following D-spec keywords, and give a brief summary of your understanding:

21. Like           3

Used as a keyword to define a variable to have the same attributes as the field specified in the keyword.                                                                                                                                                  D CustIdNum                s              20   A

D  CustIdNum2                                            Like( CustIdNum)

Used for standalone fields, prototypes, parameters and data-structure subfields. 

22. LikeDs and LikeRec         3

            Same as point 10, but no *KEY instruction specified.

23. NoOpt       2

                        Prevent optimization of data items that you do not want to optimize.

24. Overlay     3

Used in data structures to overlay DS fields in a specific memory space. Example

D Structure      DS

D   MyDStruct               10A

D     Field1                     3A   OVERLAY(MyDStruct)

D     Field2                     6A   OVERLAY(MyDStruct:4)

D     Field3                     1A   OVERLAY(MyDStruct:10)

                               

* Define subfield overlay positions with *NEXT

D Structure      DS               

D   MyDStruct              10A

D     Field1                     3A   OVERLAY(MyDStruct)

D     Field2                     6A   OVERLAY(MyDStruct:*NEXT)

D     Field3                     1A   OVERLAY(MyDStruct:*NEXT)

                       

25. Prefix        3

You can partially rename all fields in an externally described file, either add a prefix to the existing field name or you can replace part of the existing field name with a sequence of characters

FITMMSTL          IP E K DISK PREFIX(MST)

FSALESMSTR     IP E K DISK PREFIX(YE:3)

           

                                    The format is PREFIX(prefix-string:{nbr_of_char_replaced}).

Runtime Feedback and Error Handling

A programmer must have familiarity with ILE RPG’s facilities for obtaining runtime feedback, including detection and handling of runtime errors. A mix of old and new features provides the foundation for this aspect of professional RPG programming.

Rate your knowledge about the following runtime feedback structures, and give a brief summary of your understanding:

26. File Information Data Structure   3

A file information data structure (INFDS) can be defined for each file to make file exception/error and file feedback information available to the program. The file information data structure, which must be unique for each file, must be defined in the main source section. The same INFDS is used by all procedures using the files.

FMYFILE IF E DISK INFDS(FILEFBK)

DFILEFBK DS

D FILE *FILE                                                      * File name

D OPEN_IND 9 9N                                             * File open?

D EOF_IND 10 10N                                            * File at eof?

D STATUS *STATUS                                         * Status code

D OPCODE *OPCODE                                       * Last opcode

D ROUTINE *ROUTINE                                   * RPG Routine

D LIST_NUM 30 37                                           * Listing line

D SPCL_STAT 38 42S 0                                    * SPECIAL status

D RECORD *RECORD                                     * Record name

D MSGID 46 52                                                   * Error MSGID

D SCREEN *SIZE                                               * Screen size

D NLS_IN *INP                                                   * NLS Input?

D NLS_OUT *OUT                                             * NLS Output?

D NLS_MODE *MODE                                     * NLS Mode?.

27. Program Status Data Structure     2

A program status data structure (PSDS) can be defined to make program exception/error information available to an RPG IV program. The PSDS must be defined in the main source section; therefore, there is only one PSDS per module.

D Psds SDS

D Loc *ROUTINE

D Err *STATUS

D Parms *PARMS

D Name *PROC

.

Rate your knowledge about the following error detection and handling features, and give a brief summary of your understanding:

28. (E) opcode extender                              2 

            Handling Exceptions ILE RPG supports the following types of exception handlers:

a)       RPG-specific handlers, for example, the use of an error indicator, an ’E’ operation code extender, a MONITOR group, or a *PSSR or INFSR error subroutine.

b)       ILE condition handlers, user-written exception handlers that you register at run time using the ILE condition handler bindable API CEEHDLR.

c)       ILE cancel handler which can be used when a procedure ends abnormally.

C     CustNO        Chain(E)  CustMast

C                   if        %ERROR = *ON                C                   Select

C                   When      %STATUS = 1221

C                   exsr      UpdateNoRead

C                   When      %STATUS = 1218

C                   exsr      RecdLocked

C                   endSL

C                   ELSE

C                   if        %FOUND( CustMast )

C                   exsr      check

C                   endif

C                   endif

29. *PSSR subroutine             2

Code a program error subroutine, which is named *PSSR, for program exceptions. Note that a *PSSR is local to the procedure in which it is coded.

This means that a *PSSR in a main procedure will handle only those program errors associated with the main procedure. Similarly, a *PSSR in a subprocedure will only handle the errors in that subprocedure.

Fmyfile        IF     E     K  DISK                 INFSR(*PSSR)

CSR   *PSSR         begsr

C                   eval      MsgID = CPFID

C                   eval      MsgTyp = '*INFO'

C                   eval      MsgDta = CPFMsg

C                   eval      CMsgQ = '*EXT'

C                   eval      CStack = 0

C                   exsr      Sndmsg

C                   eval      *InLR = *on

C                   return

CSR                 endsr

30. Monitor blocks      2

                        MONITOR group performs conditional error handling based on the status code.

If an error occurs, control passes to the appropriate ON-ERROR group within the

MONITOR group.

C            MONITOR

C            READ FILE1

C            IFNOT %EOF

C            EVAL Line = %SUBST(Line(i) :

C            %SCAN('***': Line(i)) + 1)

C            ENDIF

C            ON-ERROR 1211

C            ... handle file-not-open

C            ON-ERROR *FILE

C            ... handle other file errors

C            ON-ERROR 00100 : 00121

C            ... handle string error and array-index error

C            ON-ERROR

C            ... handle all other errors

C            ENDMON

Rate your knowledge about the following error and I/O status built-in functions, and give a brief summary of your understanding:

31. %Eof         3

%EOF returns ’1’ if the most recent read operation or write ended in an end of file or beginning of file condition; otherwise, it returns ’0’.

C                   READ      ACCOUNT

C                   IF        %EOF(ACCOUNT)

C     'EOF'         DSPLY 

C                   ENDIF 

C                   IF        NOT %EOF(ACCOUNT)

C                   IF        %EOF 

C                   EVAL      *IN45=%EOF(ACCOUNT)

.

Please see point 30.

32. %Equal      3

%EQUAL returns ’1’ if the most recent relevant operation found an exact match; otherwise, it returns ’0’.

C     SearchName    LOOKUP    TabNames                           10  10

C                   SELECT

C                   WHEN      %EQUAL

* An exact match was found

C     'Exact       'DSPLY                   TabNames

C                   WHEN      %FOUND

* A name was found greater than SearchName

C     'Next greater'DSPLY                   TabNames

C                   OTHER

* Not found.  SearchName is greater than all the names in the table

C     'Not found   'DSPLY                   SearchName

C                   ENDSL

C                   RETURN

33. %Error       3

Returns ’1’ if the most recent operation with extender ’E’ specified resulted in an error condition. This is the same as the error indicator being set on for the operation. Before an operation with extender ’E’ specified begins, %ERROR is set to return ’0’ and remains unchanged following the operation if no error occurs. All operations that allow an error indicator can also set the %ERROR built-in function. The CALLP operation can also set %ERROR.               

Please see point 28

34. %Found    3

Returns ’1’ if the most recent relevant file operation found a record, a string operation found a match, or a search operation found an element.

Otherwise, this function returns ’0’.

Please see points 28 &32

35. %Open      3         

Returns ’1’ if the specified file is open. A file is considered ″open″ if it has been opened by the RPG program during initialization or by an OPEN operation, and has not subsequently been closed. If the file is conditioned by an external indicator and the external indicator was off at program initialization, the file is considered closed, and %OPEN returns ’0’.

               c                   If        Not %Open(FILE1)

                                         c                   Open      FILE1

                                         c                   Endif

36. %Status     2

                        Returns the most recent value set for the program or file status.

%STATUS is set whenever the program status or any file status changes, usually when an error occurs.

Please see point 28

Extended and Free-Format Syntax:

It’s now possible to write almost every bit of executable code using a more readable and flexible free-format syntax. Okay, so your nice-looking program might still be broken up by the notoriously clunky P- and D-specs to define subprocedures. Still, it’s way past time to master and use free format wherever you can.

Rate your knowledge about free-format syntax and features, and give a brief summary of your understanding:

37. Coding arithmetic and string expressions. 3

Expressions are a way to express program logic using free-form syntax. They can be used to write program statements in a more readable or concise manner than fixed-form statements.

An expression is simply a group of operands and operations. For example, the following are valid expressions:

A+B*21

STRINGA + STRINGB

D = %ELEM(ARRAYNAME)

*IN01 OR (BALANCE > LIMIT)

SUM + TOTAL(ARRAY:%ELEM(ARRAY))

'The tax rate is ' + %editc(tax : 'A') + '%.'

Functions for converting a number into a duration that can be used in arithmetic expressions: %MSECONDS, %SECONDS, %MINUTES, %HOURS, %DAYS, %MONTHS, and YEARS

38. (E) and (M) operation extenders   2

(E) Please see point 28

(M) Default precision rule, the precision of a decimal intermediate in an expression is computed to minimize the possibility of numeric overflow. However, if the expression involves several operations on large decimal numbers, the intermediates may end up with zero decimal positions. (Especially, if the expression has two or more nested divisions.) This may not be what the programmer expects, especially in an assignment.

39. Coding assignments without an explicit Eval opcode. 3

            The equal sign can be used instead (makes for easier reading of code).

                Y = A + B + C

However EVAL must be used in a case where the result field name is the same as an operational code

                EVAL READ = A + B + C

40. Using free-format syntax and Boolean expressions for control operations (e.g., If and For opcodes).         2

D pKxIndicators S * Inz(%Addr(*In))

D FunctionKeys   DS           Based(pKxIndicators)

D thisIsKC            N Overlay(FunctionKeys: 3)

D thisISKL            N Overlay(FunctionKeys: 12)

/free

If thisIsKC and Not thisIsKL;

do_something();

EndIf;

enddo;

/end-free

/free

// Load a subfile with the next 10 data records

For I = 1 to 10;

Read data_file; // Get next record or eof

If %eof(data_file); // If eof

Leave; // Jump out of For loop

Endif;

// Load subfile from data record here

Endfor;

// Leave instruction sends control here

/end-free

41. Using free-format version of opcodes for I/O and other operations.       3         

/free

Setll (Key1: Key2) MyFile;

Reade (Key1: Key2) MyFile;

Dow Not %Eof(MyFile) and %Found(MyFile);

Reade (Key1: Key2) MyFile;

EndDo

/end-free

Rate your knowledge about these equivalent built-in functions for fixed-format opcode capabilities, and give a brief summary of your understanding:

42. %BitAnd, %BitOr, %BitNot        1

* This example shows how to duplicate the function of * BITON and BITOFF using %BITAND, %BITNOT, and %BITOR

DName+++++++++++ETDsFrom+++To/L+++IDc.Keywords+++++++++++++++

D fld1            s              1a   inz(x'01')

D fld2            s              1a   inz(x'FF')   CL0N01Factor1+++++++Opcode(E)+Factor2+++++++Result++++++++Len++   C                   biton     x'F4'         fld1

* fld1 has an initial value of x'01' (0000 0001)

* The 1 bits in x'F4' (1111 0100) are set on

* fld1 has a final value of x'F5' (1111 0101)

C                   bitoff    x'F1'         fld2

* fld2 has an initial value of x'FF' (1111 1111)

* The 1 bits in x'F1' (1111 0001) are set off

* fld2 has a final value of x'0E' (0000 1110)

/free

43. %Char and other data conversion functions         3

Convert the value of the expression from graphic, UCS-2, numeric, date, time or timestamp data to type character. The converted value remains unchanged, but is returned in a format that is compatible with character data.

D Name S 20G VARYING INZ(G'oXXYYZZi')

D date S D INZ(D'1997/02/03')

D time S T INZ(T'12:23:34')

D result S 100A VARYING

D points S 10i 0 INZ(234)

/FREE

result = 'It is ' + %CHAR(time) + ' on ' + %CHAR(date);

result = 'It is ' + %CHAR(time : *jobrun)

+ ' on ' + %CHAR(date : *jobrun);

result = 'It is ' + %CHAR(time : *hms:)

+ ' on ' + %CHAR(date : *iso);

result = 'The time is now ' + %SUBST (%CHAR(time):1:5) + '.';

result = 'The customer''s name is ' + %CHAR(Name) + '.';

result = 'You have ' + %char(points) + ' points.';

/END-FREE

44. %Check and %CheckR    3

%CHECK returns the first position of the string base that contains a character that does not appear in string comparator. If all of the characters in base also appear in comparator, the function returns 0.

Dstring            S           20 A inz('ZXCV123GHJGHJ')

/Free

                If  %Check('123': String) > 0;

                //do something

                EndiF

/End-Free

%CHECKR returns the last position of the string base that contains a character that does not appear in string comparator. If all of the characters in base also appear in comparator, the function returns 0.

.           /Free

                If  %CheckR'123': String) > 0;

                 //do something

                EndiF

/End-Free

45. %Date, %Time, and %Timestamp            3

Functions for converting a character string (or date or timestamp) into a date, time, or timestamp.

Useful in retrieving current system values, year/date/time calculations facilitating different edit formats.

46. %Diff, %Years, and %Months     3

            %DIFF produces the difference (duration) between two date or time values.

%YEARS converts a number into a duration that can be added to a date or timestamp value. %MONTHS converts a number into a duration that can be added to a date or timestamp value.

47. %Div and %Rem             3

%DIV returns the integer portion of the quotient that results from dividing operands n by m. %REM returns the remainder that results from dividing operands n by m.

48. %EditC and %EditW       3

%EDITC returns a character result representing the numeric value edited according to the edit code. In general, the rules for the numeric value and edit code are identical to those for editing numeric values in output specifications.

%EDITW returns a character result representing the numeric value edited according to the edit word. The rules for the numeric value and edit word are identical to those for editing numeric values in output specifications.

49. %Lookup and %Tlookup (including binary search feature)         3

                        Functions for finding an element in an array: %LOOKUP, %LOOKUPGT,

%LOOKUPGE, %LOOKUPLT, and %LOOKUPLE.

Functions for finding an element in a table: %TLOOKUP, %TLOOKUPGT,

%TLOOKUPGE, %TLOOKUPLT, and %TLOOKUPLE.

50. %Occur 2

            Gets or sets the current position of a multiple-occurrence data structure.

51. %Scan       3

%SCAN returns the first position of the search argument in the source string, or 0 if it was not found. If the start position is specified, the search begins at the starting position. The result is always the position in the source string even if the starting position is specified. The starting position defaults to 1.

52. %SubArr   2

Returns a section of the specified array starting at start-index. The number of elements returned is specified by the optional number-of-elements parameter. If not specified, the number-of-elements defaults to the remainder of the array.                      

53. %ShtDn    3

                        Allows the programmer to determine whether the system operator has requested shutdown.

54. %SubDt    3

Extracts a portion of the information in a date, time, or timestamp value. It returns an unsigned numeric value.

55. %SubSt     3

Returns a portion of argument string. It may also be used as the result of an assignment with the EVAL operation code.

56. %Xlate      3

                        Translates string according to the values of from, to, and startpos.

57. %Xfoot     3

                        Results in the sum of all elements of the specified numeric array expression.

Array Declaration and Processing Features

Arrays are ubiquitous in application programs, and ILE RPG’s support has been significantly improved in recent releases. If you still think "array" means "multiple-occurrence data structure," it’s time to discover what you can now do with the real thing.

Rate your knowledge about the following D-spec features, and give a brief summary of your understanding:

58. Declaring two-dimensional arrays            1

D Address         DS                          DIM(20) QUALIFIED
D   Street                            30a
D   City                              20a
D   State                              2a
D   Zip                                5a
D   ZipPlus                            4a

D PrintAddr       DS                          LikeDS(Address)

D CurLine         S                    2 0

C                    If             Address(CurLine).City =
C                                      Address(CurLine - 1).City
C                    Eval           PrintAddr.City = *Blanks
C                    EndIf

59. Declaring arrays whose elements are data structures        3

D Struct              DS       

D   Elemt1                              10 A

D   Elemt2                              3p  0

D   Elemt3                                5 A

D MyArray              S                Dim(100) Like (Struct)

/Free

                 Elemt1 = '1234';

                Elemt2 =  123;

                 Elemt3 = 'TEXT';

                MyArray(1) = Struct;

/End-Free

60. Using the Inz and Overlay keywords to specify initial values for an array.         3

D DS1             DS                  OCCURS(3)
D    Fld1                        5A   INZ(’ABCDE’)
D    Fld1a                       1A   DIM(5) OVERLAY(Fld1)
D    Fld2                        5B 2 INZ(123.45)

Rate your knowledge about the following function and feature:      3

61. %Elem

Returns the number of elements in the specified array, table, or multiple-occurrence data structure.

62. Using "* " to reference all elements          3

                        If the result represents an unindexed array or an array specified as array(*), the

value of the expression is assigned to each element of the result

Based Variables and Dynamic Storage Features

Based variables and dynamic storage allocation provide greater flexibility in programs. Modern languages, such as Java, take care of storage management for you. But at least now ILE RPG lets you do such things as allocate an array with varying numbers of elements. In ILE RPG, based variables and pointers are the key to dynamic storage and are also necessary to exploit some system APIs.

Rate your knowledge about declaring and using the following types of variables, and give a brief summary of your understanding:

63. Pointer variables    2

D MyPointer                 S                *

D String                        S          100A

/Free

                                MyPointer = %Addr(String); //give me the memory address of variable string

/End-Free

64. Based variables     2

D MyPointer                 S               *

D Struct                        ds               based(MyPointer)

D   Element1                                10A

D   Element2                                10A

Rate your knowledge about the following functions and features, and give a brief summary of your understanding:

65. %Addr function                2

Returns a value of type basing pointer. The value is the address of the specified variable. It may only be compared with and assigned to items of type basing pointer.

66. %Alloc, %Dealloc, and %Realloc functions        2

            Memory management operations.

%ALLOC Function for allocating storage.

%DeAlloc Function to free the allocated storage.

%REALLOC Function for reallocating storage.

67. Pointer arithmetic (incrementing/decrementing addresses; using offsets with addresses)           2

            D P1 s *

D P2 s *

* Allocate 20 bytes of storage for pointer P1.

C ALLOC 20 P1

* Initialize the storage to 'abcdefghij'

C EVAL %STR(P1:20) = 'abcdefghij'

* Set P2 to point to the 9th byte of this storage.

C EVAL P2 = P1 + 8

* Show that P2 is pointing at 'i'. %STR returns the data that

* the pointer is pointing to up to but not incuding the first

* null-terminator x'00' that it finds, but it only searches for

* the given length, which is 1 in this case.

C EVAL Result = %STR(P2:1)

C DSPLY Result 1

* Set P2 to point to the previous byte

C EVAL P2 = P2 - 1

* Show that P2 is pointing at 'h'

C EVAL Result = %STR(P2:1)

C DSPLY Result

* Find out how far P1 and P2 are apart. (7 bytes)

C EVAL Diff = P2 - P1

C DSPLY Diff 5 0

* Free P1's storage

C DEALLOC P1

C RETURN

User-defined Procedures and Functions

Procedures and functions are the fundamental building blocks for modular programming, a practice that is essential to managing the development and modification of complex software. If you’re not writing procedures in your new ILE RPG code you’re about twenty years behind contemporary programming practices.

Rate your knowledge about defining procedures and functions, and give a brief summary of your understanding:

68. Declaring a procedure prototype (PR D-spec)      3

Prototyped calls is the recommended way to call programs and procedures. Prototype interfaces are also checked at compile time which gives a higher level of systems integrity.

D QCMDEXC         PR                  EXTPGM('QCMDEXC')       

D CMD                         3000a   CONST OPTIONS(*VARSIZE) 

D CMDLEN                        15P 5 CONST  

D 3A CONST OPTIONS(*NOPASS)                

D VAR1            S            200                            

C                   EVAL      VAR1 = 'WRKSPLF'                

C                   CALLP     QCMDEXC(VAR1:%LEN(VAR1))        

C                   EVAL      *INLR = *ON

/FREE

QCMDEXC ('WRKSPLF' : %SIZE ('WRKSPLF'));

/END-FREE

           

69. Defining a procedure — Begin-procedure and End-procedure specifications (P-specs)             2

                P FormatAddress B

D FormatAddress PI 45A

D City 20A CONST

D ProvParm 20A CONST OPTIONS(*NOPASS)

D Province S 20A INZ('Ontario')

* Set the local variable Province to the value of the second

* parameter if it was passed. Otherwise let it default to

* 'Ontario' as it was initialized.

C IF %PARMS > 1

C EVAL Province = ProvParm

C ENDIF

* Return the city and province in the form City, Province

* for example 'North York, Ontario'

C RETURN %TRIMR(City) + ',' + Province

P FormatAddress E

70. Declaring a procedure interface (PI) D-spec        2

            As above.

D FormatAddress PI 45A

71. Declaring procedure parameters (basic techniques)          2

                        D RPGHDLR PR

D Parm1 LIKE(CondTok)

D Parm2 *

D Parm3 10I 0

D RPGHDLR PI

D InCondTok LIKE(CondTok)

D pCommArea *

D Action 10I 0

D OutCondTok LIKE(CondTok) D Parm4 LIKE(CondTok)

72. Declaring and using data structure parameters     2

To define a prototyped parameter as a data structure, you must first define the layout of the parameter by defining an ordinary data structure. Then, you can define a prototyped parameter as a data structure by using the LIKEDS keyword.

73. Declaring and using array parameters       2

D Address         DS                  DIM(20) QUALIFIED
D   Street                      30a   DIM(2)
D   City                        20a
D   State                        2a
D   Zip                          5a
D   ZipPlus                      4atorage

74. Declaring and using variable-length parameters (*VarSize option)          3

Please see point 68

75. Declaring and using variable-length character-string parameters (*VarSize and *String options)             1

Pass a character value as a null-terminated string. This keyword is valid only for basing pointer parameters passed by value or by read-only reference. When OPTIONS(*STRING) is specified for a basing pointer parameter passed by value or by constant-reference, you may either pass a pointer or a character expression. If you pass a character expression, a temporary value will be created containing the value of the character expression followed by a null-terminator (x’00’). The address of this temporary value will be passed to the called program

or procedure.

76. Choosing when to pass parameters by value vs. by reference (Value keyword)                                                  2

Passing bulky data strings of parameter by value is an ‘expensive’ option when it comes to performance. When one uses the by reference option, only the reference pointers are passed where the program being called would be able to allocate it directly from memory.

Using the value keyword, one passes the data values as parameters exactly as is where the receiving program must have the exact receiving data types. It is a safer option if data in memory are changed between both the calling and called program.    

In Java, the following data types can only be passed by value:

boolean

byte

int

short

long

float

double

Parameters of these types must have the VALUE keyword specified for them on the prototype.

77. Declaring and using read-only parameters (Const keyword)       2

To specify the value of a named constant and to indicate that a parameter passed by reference is read-only.

Dprocedure                PR

D   Parm1                     10 A            CONST

D   Parm2                     10 A            CONST

/free

    Proccedure('ABC' : '123'); //The receiving procedure gets a constant value, which cannot be                                      

                                               //changed

/End-Free

78. Declaring and using optional parameters (*NoPass and *Omit options) 2

* When OPTIONS(*NOPASS) is specified on a definition specification, the parameter does not have to be passed on the call. Any parameters following that specification must also have *NOPASS specified. When the parameter is not passed to a program or procedure, the called program or procedure will simply function as if the parameter list did not include that parameter. If the unpassed parameter is accessed in the called program or procedure, unpredictable results will occur.

Please see point 68

When OPTIONS(*OMIT) is specified, then the value *OMIT is allowed for that parameter. *OMIT is only allowed for CONST parameters and parameters which are passed by reference.

Dprocedure                 pr                          extpgm('PROGRAM')

D  parm1                                           10 A   Options(*NoPass:*Omit) Const

D  parm2                                           10 A   Options(*NoPass:*Omit) Const

79. Declaring local variables in a procedure   1

Local variables are declared within the sub-procedure definition.

80. The difference between local vs. global scope of identifiers        1

In general, all items that are defined in the main source section are global, and therefore, known throughout the module. Global definitions are definitions that can be used by both the main procedure and any subprocedures within the module. They can also be exported. Items in a subprocedure, on the other hand, are local.

Local definitions are definitions that are known only inside that subprocedure. If an item is defined with the same name as a global item, then any references to that name inside the subprocedure will use the local definition.

81. The difference between static vs. automatic storage for local variables (Static keyword)           1

For a local variable of a subprocedure, the STATIC keyword specifies that the data item is to be stored in static storage, and thereby hold its value across calls to the procedure in which it is defined. The keyword can only be used within a subprocedure. All global fields are static.

 If   STATIC is not specified, then any locally defined data item is stored in automatic

Rate your knowledge about implementing procedures and functions, and give a brief summary of your understanding:

82. %Parms function   3

Number of parameters passed to procedure.

 P MaxInt BD MaxInt PI 10I 0

D p1 10I 0 VALUE

D p2 10I 0 VALUE

D p3 10I 0 VALUE OPTIONS(*NOPASS)

D p4 10I 0 VALUE OPTIONS(*NOPASS)

D p5 10I 0 VALUE OPTIONS(*NOPASS)

D Max S 10I 0 INZ(*LOVAL)

* Branch to the point in the calculations where we will never

* access unpassed parameters.

C SELECT

C WHEN %PARMS = 2

C GOTO PARMS2

C WHEN %PARMS = 3

C GOTO PARMS3

C WHEN %PARMS = 4

C GOTO PARMS4

C WHEN %PARMS = 5

C GOTO PARMS5

C ENDSL torage

83. Return expression opcode (to return a function result)    3

The RETURN operation causes a return to the calling program.

C             RETURN

If a value needs to be returned to the calling program, the return value must be specified in the expression operand.

C             RETURN               'L'

Rate your knowledge about calling procedures and functions, and give a brief summary of your understanding:

84. CallP opcode         2

To call a prototyped program or procedure written in any language.

D AddName PR

D name_parm 40A

D Display PR

D Free PR

C CALLP AddName(name)

C CALLP Display

C CALLP Free

85. The difference between a dynamic program call (Call or CallP) vs. a static procedure call (CallB or CallP) 2

Dynamic - The CALL operation passes control to the OPM program specified in factor 2. Validation is done at compile time (e.g. program parameter/s).

The compiler cannot perform type checking on the parameters, which may result in run-time errors.

Static - The CALLB operation is used to call bound procedures written in any of the ILE languages.

Validation is done at runtime.

Run-time performance is faster.

Allow operational descriptors, omitted parameters, and they extend the limit (to 399) on the number of parameters that are passed.

Source Code Inclusion Features

Code reuse is one of the simplest, yet most powerful techniques to save time and improve consistency.

Rate your knowledge about the following source code inclusion features, and give a brief summary of your understanding:

86. Option( *NoShowCpy ) keyword on H-spec       2

Specifies the options to use when the source member is compiled.

Do not show source records of members included by the /COPY compiler directive.

This will affect debug.

87. /Copy compiler directive   2

When coding a module with multiple procedures, you will want to make use of /COPY files, primarily to contain any prototypes that your application may require. If you are creating a service program, you will need to provide both the service program and the prototypes, if any.

88. /Include compiler directive           2

The /COPY and /INCLUDE compiler directives cause records from other files to be inserted, at the point where the directive occurs, with the file being compiled. The inserted files may contain any valid specification including /COPY and /INCLUDE up to the maximum nesting depth specified by the COPYNEST keyword (32 when not specified).

These directives have the same purpose and the same syntax, but are handled differently by the SQL preprocessor. If your program does not have embedded SQL, you can freely choose which directive to use. For SQL use /INCLUDE.

89. /Eof compiler directive     2

The /EOF directive tells the compiler to ignore the rest of the source lines in the current source member.

Enhancing compile-time performance when an entire /COPY member is to be used only once, but may be copied in multiple times. (This is not true if excluded lines are being printed).

Conditional Compilation

Conditional compilation is another simple technique that’s immensely useful for testing, problem diagnosis, and expanded code reuse.

Rate your knowledge about the following conditional compilation features, and give a brief summary of your understanding:

90. Option( *NoShowSkp ) keyword on H-spec       2

Do not show ignored statements in the source part of the listing.

The compiler ignores statements as a result of /DEFINE, /UNDEFINE/IF, /ELSEIF or /ELSE or /ENDIF and /INCLUDE directives. /EJECT directive does not cause a page break. Similarly, /SPACE, /TITLE, /COPY and /EOF compiler directives are ignored if they are encountered; instead a message is printed giving the number of lines excluded.

91. /Define and /Undefine compiler directives           1

 Please see point 90

 The conditional compilation directive statements allow you to conditionally include or exclude sections of source code from the compile.

Condition-names can be added or removed from a list of currently defined conditions.

92. /If, /Else, /ElseIf, and /EndIf compiler directives             1

If the condition expression is true, source lines following the /IF directive are selected to be read by the compiler. Otherwise, lines are excluded until the next /ELSEIF, /ELSE or /ENDIF in the same /IF group.

93. Define parameter on CrtBndRpg and CrtRpgMod commands 3

Create a Bound RPG Program - With this command you can create one of two types of ILE programs:

1. OPM-compatible programs with no static binding

2. Single-module ILE programs with static binding

Create RPG Module (CRTRPGMOD) command. This command compiles the source statements into a module object. A module is a nonrunnable object; it must be bound into a program object to be run. To bind one or more modules together, use the Create Program

(CRTPGM) command. Create a module using the Create RPG Module (CRTRPGMOD)

OS/400 ILE Modular Programming Features

To practice modular programming with ILE RPG, you must understand related OS/400 ILE features for creating and running programs and service programs.

Rate your knowledge about the following OS/400 ILE features, and give a brief summary of your understanding:

94. Creating a program from multiple modules (CrtPgm command) 1

The Create Program (CRTPGM) command creates a program object from one or more previously created modules and, if required, one or more service programs.

You can bind modules created by any of the ILE Create Module commands,

CRTRPGMOD, CRTCMOD, CRTCBLMOD, or CRTCLMOD.

CRTPGM PGM(MYPROGRAM) MODULE(*LIBL/MYMODULE1 *LIBL/MYMODULE2 *LIBL/MYMODULE3)

95. Creating a service program from multiple modules (CrtSrvPgm command)        1

Service programs are a means of packaging the procedures in one or more modules into a separately bound object. Other ILE programs can access the procedures in the service program, although there is only one copy of the service program on the system. The use of service programs facilitates modularity and maintainability. You can use off-the-shelf service programs developed by third parties or, conversely, package your own service programs for third-party use.

CRTSRVPGM SRVPGM(MYSERVICES) MODULE(MODULE1 MODULE2)

96. Creating a program or service program with references to procedures in a (different) service program           0

97. Specifying an activation group for a program or service program            1

ILE programs and service programs are activated into activation groups which are specified at program-creation time. The process of getting a program or service program ready to run is known as activation. Activation allocates resources within a job so that one or more programs can run in that space. If the specified activation group for a program does not exist when the program is called, then it is created within the job to hold the program’s activation. An activation group is the key element governing an ILE application’s resources and behavior. For example, you can scope commitment-control operations to the activation group level.

98. Bind-by-copy vs. bind-by-reference         0

The function of the binder is similar to, but somewhat different from, the function provided by a linkage editor. The binder processes import requests for procedure names and data item names from specified modules. The binder then tries to find matching exports in the specified modules, service programs, and binding directories.

In creating an ILE program or service program, the binder performs the following types of binding: Bind-by-copy or bind-by-reference.

99. Exporting procedure names          1

The specification of the EXPORT keyword allows a globally defined data structure or standalone field defined within a module to be used by another module in the program. The storage for the data item is allocated in the module containing the EXPORT definition. The external name parameter, if specified, must be a character literal or constant. The EXPORT keyword on the definition specification is used to export data items and cannot be used to export procedure names. To export a procedure name, use the EXPORT keyword on the procedure specification

STRPGMEXP PGMLVL(*CURRENT) SIGNATURE('MYSIGNATURE')

       EXPORT SYMBOL('MyProcdure1')

       EXPORT SYMBOL('MyProcdure2')

ENDPGMEXP

           

100. Using binder language    1

If the interface to a service program changes, then you may have to re-bind any programs bound to the original service program. However, if the changes required are upward-compatible, you may be able to reduce the amount of re-binding if you created the service program using binder language. In this case, after updating the binder language source to identify the new exports you need to re-bind only those programs that use them.

101. Using a binding directory 1

A binding directory contains the names of modules and service programs that you may need when creating an ILE program or service program. Modules or service programs listed in a binding directory are used only if they provide an export that can satisfy any currently unresolved import requests. A binding directory is a system object that is identified to the system by the symbol *BNDDIR.

Completion

Thank you for taking the time to complete this score card.