Sat, May
7 New Articles

What? RPG IV a Better C Than C?

  • Smaller Small Medium Big Bigger
  • Default Helvetica Segoe Georgia Times
Since the introduction of ILE with OS/400 V3R1, RPG has been gaining ground on C in flexibility of algorithmic expression, ability to interoperate in a mixed-language setting, and performance. With each software-focused release, RPG can been seen as at least running neck-and-neck with C. In some cases, RPG even surpasses C in language-enhancing features:

  • Separation of source compilation and module binding steps (providing linkage to other ILE languages)
  • Addition of built-in functions (BIFs), which provide continued language extension
  • Introduction of smaller bindable units with subprocedures (not limited to just program-level calls)
  • Comprehensive pointer manipulation support (two types of pointers: a generic data pointer and a procedure pointer)
  • Dynamic (runtime) memory allocation on free store
  • Data type support for short, regular, and long integers, both signed and unsigned; floats and doubles; pointers; and Java objects
  • Bit manipulation with XOR, AND, and OR BIFs (V5R2)
  • Abstract Data Type (ADT) support--like structs in C
  • Arguments passed to functions either by reference (lacking from C) or by value
  • Free-form language expression for program logic (calc specs), but data specifications remain fixed (which is fine since data must be structured to be usable)
  • Better interoperability with Java--raw Java Native Interface (JNI) required for C
  • Conditional compiler directives
  • Thread safety (same as C)
  • Language-dependent or -independent error handling

Those are just a few of the advantages ILE RPG IV (as of V5R2) added to the programmer's arsenal to combat the fluid nature of computing requirements in today's environment. And you must not forget that anything C can bind with, RPG can bind with as well. For example, before RPG had the capability to convert character data to numeric, you could use C's atoi() and atof() functions to accomplish that objective. On a recent project, I avoided completely rewriting a file editing application (a DBU-like utility) by replacing RPG I/O operations with equivalent C I/O functions. This was required because RPG does not provide the runtime null field support for program-described files (which is what you must do to achieve dynamic file maintenance in RPG) that can be accomplished in C. While this was not a trivial task, it was not difficult either. (Watch for a future MCMagOnline article entitled "How Could Life Be Better?" for an example of this.)

A Better View

By way of example, Figure 1 shows a functional code snippet that uses C's printf(), prototyped in [B], where you might have previously used the DSPLY opcode to list address information from two variables (var1 and var2 shown at [D]) created from the ADT address [A].

     h dftactgrp(*no) actgrp(*new) datfmt(*usa) bnddir('QC2LE') 

 [A] d address         ds
     d   name                        25a   inz('No Name')
     d   add1                        30a   inz('No address 1')
     d   add2                        30a   inz('No address 2')
     d   city                        15a   inz('No city')
     d   state                        2a   inz('NA')
     d   zip                         10u 0
     d   dob                           d

 [B] d printf          pr                  extproc('printf')
     d                                 *   value options(*string)
     d                                 *   value options(*string:*nopass)
     d                                 *   value options(*string:*nopass)
     d                               10u 0 value options(*nopass)

     d printf2         pr                  extproc('printf')
     d                                 *   value options(*string)
     d                               10u 0 value options(*nopass)

     d separator       s             30a   inz('* * * * * * * * * * * *')
 [C] d newline         c                   x'25'
     d index           s             10i 0
     d total_addresses...
     d                 s             10i 0

      *----- Applied versions of ADT address
 [D] d var1            ds                  likeds(address)
     d var2            ds                  likeds(address)


       var1.name = 'John Doe';
       var1.dob = %date('03/23/1977':*usa);
       var1.add1 = 'c/o Jane Doe';
       var1.add2 = 'Apt. 225';
       var1.city = 'Somewhere';
       var1.state= 'TX';
       var1.zip = 73533;
       total_addresses = total_addresses + 1;

       var2.name = 'Jane Doe';
       var2.dob = %date('12/09/1977':*usa);
       var2.add1 = '23 N. Lancaster';

       // following statement causes string error and branch to on-error
       // program resumes upon return with statement following the statement
       // which caused on-error to be called.

       %subst(var2.add2:index:30) = 'String index error';
       on-error 00100 : 00121;  // Traps string error where it occurs
                                // on-error here allows processing to
                                // continue

       var2.city = 'Somewhere Else';
       var2.state= 'TX';
       var2.zip = 77381;
       total_addresses = total_addresses + 1;

  [E]  printf('Name:    %s' + newline :var1.name);
       printf('Address: %s' + newline :var1.add1);
       printf('Address: %s' + newline :var1.add2);
       printf('City:    %s  State: %s  Zip: %d'
                        + newline
       printf('Date of birth: %s' + newline :%char(var1.dob));

       printf('%s' + newline :separator);

       printf('Name:    %s' + newline :var2.name);
       printf('Address: %s' + newline :var2.add1);
       printf('City:    %s  State: %s  Zip: %d'
                        + newline
       printf('Date of birth: %s' + newline :%char(var2.dob));

       printf('%s' + newline :separator);

       if ( var1.state = var2.state );
           printf('%s' + newline :'Hey, these guys +
                                   live in the same state!');

 [F]   printf2('Total addresses listed: %d' + newline :total_addresses);

       on-error *all;   // This is like MONMSG CPF0000 with branch to
                        // end
           printf('%s' + newline :'Fatal error occurred. +
                                   Processing haulted!');

       *inlr = *on;

Figure 1: Use C's printf() where you might have previously used the DSPLY opcode.

Yet printf() is a better solution because you can format the output better than with DSPLY, and you can scroll to see previous output produced from using the printf statement. The printf function is defined in C as a variable-arguments function, which is indicated by the ellipses (...) shown in the following C prototype:

int      printf(const  char *, ...);

However, since RPG IV cannot define such a function, you can emulate this functionality by prototyping multiple versions of the printf function, all bound to the same C printf binary but with different prototype names. When creating your own prototypes for printf required by your application, the only requirement is that the first argument be defined as a pointer to a null-terminated string (referred as the format-string argument, i.e., containing format conversion identifiers like %s,%c,%d,%f, etc.). A list of these format conversion identifiers are shown in a table in the printf() documentation in the ILE C/C++ Run-Time Library Reference). Every argument following the first can be any valid data type defined in C (e.g., integer, float, double, etc.). This will accommodate most requirements for debugging your applications.

An example of this is shown in [B] of Figure 1 where the printf2 function takes an integer argument after the initial string argument to print the total number of addresses defined from the ADT address. This calculation immediately follows the ZIP code initialization for each address variable and is printed as the last and only output line printed by the printf2 prototyped variation of the printf C function as shown in [F] of Figure 1.

The Great Escape

The C shell output window is invoked to display the results of printf when the activation group is set to *new. You should be aware that since RPG does not invoke the C precompiler, escape sequence characters like ' ' (new line or linefeed), ' ' (tab), etc. are not translated to their equivalent hex values. (For a complete list of escape sequence characters, refer to Escape Sequences and Appendix A-AS/400 Control Characters in the ILE C Language Reference.) For this reason, the newline standalone variable shown in [C] was defined with a value of x'25' (x'15' if using *IFSIO) to enable a linefeed after outputting the results. You will need to do the same for any other escape sequence characters you wish to embed in the output. This is a small price to pay for the superior output achieved using printf(). Displaying the data in the variables (var1, var2) is a simple matter of using the identical qualifying dot (.) notation used in C to access structure data members as shown in [E] of Figure 1. The "%s" notation in the formatted output string is used to print the string data of var1.name and is a standard C formatter character.

Like DSPLY, the printf function can be handy for debugging your applications.

Note that even though Figure 1 presents the use of printf() in free-form expressions, you can also use it in fixed-form expressions with a CALLP. Note the similarities when all forms of the printf() are put together, as in Figure 2:

Fixed Form: Callp(e) printf('City: %s State: %s Zip: %d'
+ newline

Free Form: printf('City: %s State: %s Zip: %d'
+ newline

C equivalent: printf("City: %s State: %s Zip: %d "

Figure 2: You can use printf() in both free-form and fixed-form expressions.

Watch the Gotchas!

There are some noteworthy "gotchas" when mixing C with RPG:

  • A single character returned from a C function will be promoted (also called "widening") to an integer of 4 bytes versus the 1 byte expected. The value will be right-justified to appear in the last byte of the integer.
  • When a C function calls an RPG IV subprocedure that contains the %parms BIF (that normally seems to work fine when called by another RPG subprocedure), the value returned from that BIF is not what the programmer expects--the number of arguments passed in. The result is always -1 (meaning an error occurred) because RPG always passes a minimal operational descriptor to called functions, while languages like C do not by default, unless specifically directed to. Since the %parms BIF cannot determine the number of arguments passed to the RPGIV subprocedure, use the ILE CEE API CEETSTA instead to get the number of arguments passed to an RPG IV subprocedure when called from C (read the requirements and limitations of this API carefully; they will affect the manner in which arguments are passed and the order of argument definition in the called function).
  • Null-terminate strings passed to C functions and remove the null-termination character when a string is returned with the %str BIF.
  • Use the ALIGN keyword to align structures (or a pointer to a C structure) passed to a C function or returned when the _Packed keyword has been omitted from the structure definition (in the called C function) to ensure consistent boundary alignment between caller and called function.
  • Constant pointers (as in "char * const") are references (think of them as pointers to pointers) to pointer values, not the actual pointer value themselves. As such, they must be de-referenced before used as a based on value for a standalone variable or data structure. (See an example of how to do this in RPG IV in the upcoming article "How Could Life Be Better?")


Some of the Best Tools Are Found in Unlikely Places

If you are an RPG programmer in a shop with C programmers, you have undoubtedly had extensive debates regarding the advantages of C vs. RPG and concluded that it comes down to which language you are most comfortable with and what your corporate strategy is regarding the portability of source. However, if portability is not an issue and you need some features in the standard C library, they come free with OS/400 and you don't need the C compiler to use them. Yet to take advantage of this situation to its fullest benefit, it helps if you learn a few simple C basics to understand how to create the RPG prototypes you will need for the C functions you wish to use. (Unfortunately, IBM has not seen fit to include RPG prototypes in QSYSINC. I hope this changes in the future.) But note that as of V5R1, the C function prototypes previously available only with the licensing of the C language now have a new home in QSYSINC.

The more you use C functions in your daily application requirements, the more C you will learn by default. This could be advantageous if you later wish to learn C++ (or Java), another beautiful language (like RPG IV) that has also been dubbed "a better C than C."

Jim Barnes is a freelance writer and independent consultant working in Houston, Texas. Jim can be reached at This email address is being protected from spambots. You need JavaScript enabled to view it..

References and Related Materials

ILE C for AS/400 Language Reference (SC09-2711-00)

ILE C/C++ Run-Time Library Reference (SC09-2715-00)


Jim D. Barnes is a freelance writer and Systems Engineer in Plano, Texas.



Support MC Press Online

$0.00 Raised:

Book Reviews

Resource Center

  • SB Profound WC 5536 Have you been wondering about Node.js? Our free Node.js Webinar Series takes you from total beginner to creating a fully-functional IBM i Node.js business application. You can find Part 1 here. In Part 2 of our free Node.js Webinar Series, Brian May teaches you the different tooling options available for writing code, debugging, and using Git for version control. Brian will briefly discuss the different tools available, and demonstrate his preferred setup for Node development on IBM i or any platform. Attend this webinar to learn:

  • SB Profound WP 5539More than ever, there is a demand for IT to deliver innovation. Your IBM i has been an essential part of your business operations for years. However, your organization may struggle to maintain the current system and implement new projects. The thousands of customers we've worked with and surveyed state that expectations regarding the digital footprint and vision of the company are not aligned with the current IT environment.

  • SB HelpSystems ROBOT Generic IBM announced the E1080 servers using the latest Power10 processor in September 2021. The most powerful processor from IBM to date, Power10 is designed to handle the demands of doing business in today’s high-tech atmosphere, including running cloud applications, supporting big data, and managing AI workloads. But what does Power10 mean for your data center? In this recorded webinar, IBMers Dan Sundt and Dylan Boday join IBM Power Champion Tom Huntington for a discussion on why Power10 technology is the right strategic investment if you run IBM i, AIX, or Linux. In this action-packed hour, Tom will share trends from the IBM i and AIX user communities while Dan and Dylan dive into the tech specs for key hardware, including:

  • Magic MarkTRY the one package that solves all your document design and printing challenges on all your platforms. Produce bar code labels, electronic forms, ad hoc reports, and RFID tags – without programming! MarkMagic is the only document design and print solution that combines report writing, WYSIWYG label and forms design, and conditional printing in one integrated product. Make sure your data survives when catastrophe hits. Request your trial now!  Request Now.

  • SB HelpSystems ROBOT GenericForms of ransomware has been around for over 30 years, and with more and more organizations suffering attacks each year, it continues to endure. What has made ransomware such a durable threat and what is the best way to combat it? In order to prevent ransomware, organizations must first understand how it works.

  • SB HelpSystems ROBOT GenericIT security is a top priority for businesses around the world, but most IBM i pros don’t know where to begin—and most cybersecurity experts don’t know IBM i. In this session, Robin Tatam explores the business impact of lax IBM i security, the top vulnerabilities putting IBM i at risk, and the steps you can take to protect your organization. If you’re looking to avoid unexpected downtime or corrupted data, you don’t want to miss this session.

  • SB HelpSystems ROBOT GenericCan you trust all of your users all of the time? A typical end user receives 16 malicious emails each month, but only 17 percent of these phishing campaigns are reported to IT. Once an attack is underway, most organizations won’t discover the breach until six months later. A staggering amount of damage can occur in that time. Despite these risks, 93 percent of organizations are leaving their IBM i systems vulnerable to cybercrime. In this on-demand webinar, IBM i security experts Robin Tatam and Sandi Moore will reveal:

  • FORTRA Disaster protection is vital to every business. Yet, it often consists of patched together procedures that are prone to error. From automatic backups to data encryption to media management, Robot automates the routine (yet often complex) tasks of iSeries backup and recovery, saving you time and money and making the process safer and more reliable. Automate your backups with the Robot Backup and Recovery Solution. Key features include:

  • FORTRAManaging messages on your IBM i can be more than a full-time job if you have to do it manually. Messages need a response and resources must be monitored—often over multiple systems and across platforms. How can you be sure you won’t miss important system events? Automate your message center with the Robot Message Management Solution. Key features include:

  • FORTRAThe thought of printing, distributing, and storing iSeries reports manually may reduce you to tears. Paper and labor costs associated with report generation can spiral out of control. Mountains of paper threaten to swamp your files. Robot automates report bursting, distribution, bundling, and archiving, and offers secure, selective online report viewing. Manage your reports with the Robot Report Management Solution. Key features include:

  • FORTRAFor over 30 years, Robot has been a leader in systems management for IBM i. With batch job creation and scheduling at its core, the Robot Job Scheduling Solution reduces the opportunity for human error and helps you maintain service levels, automating even the biggest, most complex runbooks. Manage your job schedule with the Robot Job Scheduling Solution. Key features include:

  • LANSA Business users want new applications now. Market and regulatory pressures require faster application updates and delivery into production. Your IBM i developers may be approaching retirement, and you see no sure way to fill their positions with experienced developers. In addition, you may be caught between maintaining your existing applications and the uncertainty of moving to something new.

  • LANSAWhen it comes to creating your business applications, there are hundreds of coding platforms and programming languages to choose from. These options range from very complex traditional programming languages to Low-Code platforms where sometimes no traditional coding experience is needed. Download our whitepaper, The Power of Writing Code in a Low-Code Solution, and:

  • LANSASupply Chain is becoming increasingly complex and unpredictable. From raw materials for manufacturing to food supply chains, the journey from source to production to delivery to consumers is marred with inefficiencies, manual processes, shortages, recalls, counterfeits, and scandals. In this webinar, we discuss how:

  • The MC Resource Centers bring you the widest selection of white papers, trial software, and on-demand webcasts for you to choose from. >> Review the list of White Papers, Trial Software or On-Demand Webcast at the MC Press Resource Center. >> Add the items to yru Cart and complet he checkout process and submit

  • Profound Logic Have you been wondering about Node.js? Our free Node.js Webinar Series takes you from total beginner to creating a fully-functional IBM i Node.js business application.

  • SB Profound WC 5536Join us for this hour-long webcast that will explore:

  • Fortra IT managers hoping to find new IBM i talent are discovering that the pool of experienced RPG programmers and operators or administrators with intimate knowledge of the operating system and the applications that run on it is small. This begs the question: How will you manage the platform that supports such a big part of your business? This guide offers strategies and software suggestions to help you plan IT staffing and resources and smooth the transition after your AS/400 talent retires. Read on to learn: