IBM Power Ideas Portal


This portal is to open public enhancement requests against IBM Power Systems products, including IBM i. To view all of your ideas submitted to IBM, create and manage groups of Ideas, or create an idea explicitly set to be either visible by all (public) or visible only to you and IBM (private), use the IBM Unified Ideas Portal (https://ideas.ibm.com).


Shape the future of IBM!

We invite you to shape the future of IBM, including product roadmaps, by submitting ideas that matter to you the most. Here's how it works:

Search existing ideas

Start by searching and reviewing ideas and requests to enhance a product or service. Take a look at ideas others have posted, and add a comment, vote, or subscribe to updates on them if they matter to you. If you can't find what you are looking for,

Post your ideas

  1. Post an idea.

  2. Get feedback from the IBM team and other customers to refine your idea.

  3. Follow the idea through the IBM Ideas process.


Specific links you will want to bookmark for future use

Welcome to the IBM Ideas Portal (https://www.ibm.com/ideas) - Use this site to find out additional information and details about the IBM Ideas process and statuses.

IBM Unified Ideas Portal (https://ideas.ibm.com) - Use this site to view all of your ideas, create new ideas for any IBM product, or search for ideas across all of IBM.

ideasibm@us.ibm.com - Use this email to suggest enhancements to the Ideas process or request help from IBM for submitting your Ideas.

Add a new idea Subscribe
Status Under review
Workspace IBM i
Categories Languages - RPG
Created by Guest
Created on Apr 27, 2026

RELATED IDEAS

not %passed parameters can be not %passed for successive procedures

When we call a procedure that allow optionnal parameters, then to call successive procedures that again allow optionnal parameters, we need to check each one, then we can either call the next procedure with default value, or make a call for each combination of *omit/*nopass.

If we could call the second procedure directly and a parameter that has been omitted is always considered as omitted, it'd be much easier.


For example:

dcl-proc ProcA;

dcl-pi *n ind;

parm1 int(5) const;

parm2 int(5) const options(*omit :*nopass);

end-pi;

// Do stuff with parm1

return ProcB(parm2);

end-proc;


dcl-proc ProcB;

dcl-pi *n ind;

parm2 int(5) const options(*omit :*nopass);

end-pi;

if %passed(parm2);

snd-msg %char(parm2);

endif;

return *on;

end-proc;

Idea priority Medium
  • Guest
    Jun 4, 2026
    IBM has received your Idea and is evaluating it. IBM will provide a response after evaluation is complete.

    - IBM Power Systems Development
    Reply
  • Guest
    May 21, 2026

    This becomes much more complex when several optional parameters are involved.

    The desired improvement would be to provide a simpler and safer way to propagate an unavailable optional value through several procedure layers.


    One possible solution would be to allow optional parameters to be forwarded transparently. For example:

    return ProcB(parm2);

    If parm2 was passed to ProcA, it would be passed to ProcB.

    If parm2 was not passed to ProcA, ProcB would also see it as not passed.

    If parm2 was explicitly omitted, ProcB would receive an equivalent omitted/no-value state.


    Another complementary solution would be to improve the handling of *NULL for parameters passed by reference.

    For example, if *NULL could be passed to a CONST parameter, it could act as a stable “no value” marker that can be forwarded from procedure to procedure:


    ProcA(*NULL)

    ProcA -> ProcB(parm2)


    ProcB still receives parm2 as null/no-value.


    The purpose of this proposal is not necessarily to change the existing semantics of *OMIT, *NOPASS, %PASSED, %OMITTED, or %PARMS.

    The goal is to provide either:

    - an implicit way to forward optional parameters without having to manually test each one like this:

    if %passed(parm2);

    return ProcB(parm2);

    else;

    return ProcB();

    endif;

    - or an explicit nullable argument mechanism, such as *NULL, that can safely travel through multiple procedure calls.


    This would greatly simplify wrapper procedures, service program APIs, and layered business logic, where optional parameters often need to be passed through several intermediate procedures before they are actually used.

    Reply

By clicking the "Post Comment" or "Submit Idea" button, you are agreeing to the IBM Ideas Portal Terms of Use.
Do not place IBM confidential, company confidential, or personal information into any field.