× The internal search function is temporarily non-functional. The current search engine is no longer viable and we are researching alternatives.
As a stop gap measure, we are using Google's custom search engine service.
If you know of an easy to use, open source, search engine ... please contact support@midrange.com.




-----Original Message-----
From: Hans Boldt [mailto:boldt@ca.ibm.com]
Sent: Monday, August 19, 2002 7:41 AM
To: rpg400-l@midrange.com
Subject: It's That Time Again! The 2002 RPG Enhancement Poll


Good day.
As usual, myself and the whole RPG IV development team would like to
have your input on future RPG IV enhancements. This is your chance
to influence what goes in a future release of the RPG IV language.

YOU ARE ON  THE VOTERS LIST! YOU ARE ELIGIBLE TO VOTE! DON'T MISS
THIS CHANCE TO VOTE!

Same rules apply as before, you have $100 to spend.  Fill your
election ballot with up to $100 worth of the following proposed
enhancements.  Be careful not to spend more than $100.  If you do,
your votes will not be counted.

Vote by marking an 'X' between the square brackets [ ] at the
beginning of each selected item in the ballot.  More detailed
descriptions of each item follow the ballot.

Please return your completed ballot to farr@ca.ibm.com

We welcome any additional comments or any enhancements you think
should be considered.

I am asking my RPG technical leads: Hans Boldt and Barbara Morris to
post this note on forums and newsgroups as well. If you know of
other who might be interested in voting, please pass this note on to
them.

Please note, this is just to prioritize our line items for the next
release (beyond V5R2). In few weeks I will post the results!

Thanks in advance.

Start of ballot
============================================================================
=============
Mark an X for the items you want totaling no more than $100.

e-mail the completed ballot to farr@ca.ibm.com.

[X] Num Cost  Summary
--- --- ----  -------

[ ]   1  $10  H-spec keyword EXTDEFS to use the internal format of
ext fields.
[X]   2  $30  RANGE and VALUES keywords.
[ ]   3  $25  SORTA arr1 {: arr2 ...} WITH key_arr1 {: key_arr2 ...}
[X]   4   $5  Extender on SORTA to reverse the order of sorting.
[ ]   5   $5  DEBUG(*RETVAL) to allow debugging of procedure return
values
[ ]   6   $5  OPTIONS(*VARTYPE) to bypass type match of procedure parms
[ ]   7  $10  New BIFs %TESTD, %TESTT, and %TESTZ.
[X]   8  $50  Allow dynamic resizing of arrays and multi-occurrence DS.
[ ]   9   $5  Format change on a LIKE define for numerics.
[ ]  10  $10  New keyword, RECPREFIX, to prefix record-format names.
[ ]  11  $10  DIM(*FIT) with overlay field.
[ ]  12  $50  Multiple-dimension arrays (expressions only).
[ ]  13  $40  SPECIAL files to handle all I/O opcodes, including
keyed ops
[ ]  14   $5  %OFFSET builtin function returns offset of subfield.
[ ]  15  $20  Multiple array element initialization.
[ ]  16  $10  Keyword EXTDESC, like EXTFILE, but used at compile time
[ ]  17  $20  Dynamic specification of basing variable, ie "p->var".
[X]  18  $20  Option *ZEROFILL on %EDITC to include leading zeros.
[ ]  19  $20  Option to edit negative numbers using parentheses.
[ ]  20  $10  ALIAS name support for externally described data
structures.
[ ]  21   $5  Second parameter on %TRIMx - char to trim.
[ ]  22  $10  Built-in function %COND(condition:truevalue:falsevalue).
[ ]  23  $80  Allow expressions as parameters to keywords.
[XXXX]  24  $80  Full null field support.
[ ]  25  $80  Procedure name overloading based on parm types.
[ ]  26  $15  /FREE should allow longer than 80 character lines.
[ ]  27   $5  Allow EXTPGM to be coded without a parameter.
[X]  28  $20  Extend INDDS to associate DS with specific record format.
[ ]  29  $20  Allow named data structure bigger than 64k bytes long.
[ ]  30  $10  Keyword TEMPLATE to define DS without allocating storage.
[ ]  31  $20  EVALC move corresponding from one data structure to
another.
[ ]  32  $10  Allow BASED(%ADDR(something)).
[ ]  33  $20  Allow variable offset for data structure subfields.
[ ]  34  $40  Provide support for inlining procedures.
[ ]  35  $20  TIME opcode to provide more precise time.
[ ]  36  $40  Additional parameter passing mechanisms.
[X]  37   $5  Option to pass trimmed string as parameter.
[ ]  38  $15  Allow keyword CONST for variables
[ ]  39  $10  Conversion of date/time/tstamp to numeric using %INT,
%DEC.
[ ]  40  $15  Runtime level-check for externally-described data
structures.
[ ]  41  $10  LEAVE-WHEN & ITER-WHEN: single-statement conditional
leave or iter.

End of ballot
============================================================================
==============

-------------------------------------------------------------------------
#1   $10   H-spec keyword EXTDEFS to indicate that the internal format
            of a field should be the same as the external format.  This
            would mean that all external formats for fields must be
            the same.  (This would be a problem for programs that have
            a field defined as packed in the database but zoned in the
            display file.  Alternatives: 1) error if conflicting
            definitions, 2) first definition takes precedence)
-------------------------------------------------------------------------
#2   $30   Allow specification of the values allowed for a field with
            D spec keywords RANGE and VALUES.

            Example:
              D temperature     S          10i 0   range(-60: 120)
              D command         S           3a     values('ADD': 'DEL')

            If a value is assigned that is not correct, an exception
            would be given.  The TEST operation (and possibly a %TEST
            built-in function) would be allowed for the field.  If the
            field is used, and it has an incorrect value, an exception
            would be issued.
-------------------------------------------------------------------------
#3   $25   SORTA arr1 {: arr2 ...} WITH key_arr1 {: key_arr2 ...}
            All the arrays including key_arrays are sorted, but the
            sort sequence is determined by the key arrays.  (For
identical
            key values in key_arr1, values in subsequent key arrays are
            used.)
-------------------------------------------------------------------------
#4    $5   Extender on SORTA to specify the order of sorting.
            SORTA(A) for ascending, SORTA(D) for descending.  This would
            normally be used for non-sequenced arrays.  (If a
sequence is
            specified on the array definition, this extender must match
            if specified.)
-------------------------------------------------------------------------
#5    $5   Option DEBUG(*RETVAL) to allow seeing procedure return
            values in the debugger:
                EVAL _QRNU_RET_procname
-------------------------------------------------------------------------
#6    $5   OPTIONS(*VARTYPE) on a parameter definition for reference
            parameters to bypass type checking for the parm.  A pointer
            parm would be coded in the PI for that parameter.  It
would be
            the responsibility of the programmer to access the data
using
            based variables of the expected types.
-------------------------------------------------------------------------
#7   $10   New BIFs %TESTD, %TESTT, and %TESTZ to check if a particular
            string is a valid date, time, or timestamp value.  The 1st
            argument is the string to check; the 2nd is a format.  This
            can also be used to check if a date can be converted without
            error to a different format.

            New BIF %TEST to check if a particular variable has a value
            that's consistent with the variables definition.  For
example,
            to check if a zoned decimal variable has proper numeric
data.
-------------------------------------------------------------------------
#8   $50   Allow dynamic resizing of arrays and multi-occurrence data
            structures.

            This would mean that SORTA, LOOKUP and range-checking
would use
            the new size.  For based arrays, the programmer would be
            responsible for storage management.  For non-based
arrays, the
            compiler would handle it.  The array or mods is prefixed
in storage
            by current number of elements with either a 2 or 4 byte
unsigned
            integer.

            Example of extending sizes of arrays:

            D mods         DS                  OCCURS(10:*VAR)
            D array        S            10A    DIM(100:*VAR)
            D basedarr     S             1A    BASED(P) DIM(32767:*VAR4)
             /free
                 // Example of changing the size of a non-based
                 // varying-sized array and MODS.
                 %ELEM(array) = new_size;
                 %OCCURS(mods) = new_size;

                 // Example of one way to change the size of
                 // a based varying-sized array:
                 monitor;
                    // Try to assign to i'th element of array
                    basedarr(i) = 'x';
                 on-error 121;     // Array index out of range
                    // If we don't have storage yet for i'th element,
                    // reallocate storage for array:
                    p = %realloc(p: i * %size(basedarr) + 4); // 4
for # elems
                    %ELEM(basedarr) = i;
                    basedarr(i) = 'x';
                 endmon;
             /end-free
-------------------------------------------------------------------------
#9    $5   Format change on a LIKE define for numerics.  For example:

               D fld1            s        5s 0
               D fld2            s         p      like(fld1)
               D fld3            s        5a
               D fld4            s         p 3    like(fld3)
-------------------------------------------------------------------------
#10  $10   New keyword, RECPREFIX, to prefix record-format names to
            save having to do several renames.
               Fmyfile     IF     E        DISK   RECPREFIX(AB)
            vs
               Fmyfile     IF     E        DISK   RENAME(REC1 : ABREC1)
                                                  RENAME(REC2 : ABREC2)
-------------------------------------------------------------------------
#11  $10   DIM(*FIT) with overlay field.  Number of dimensions is
            computed based on what will fit into the overlayed field.
            (Valid only if the array fits exactly.)
-------------------------------------------------------------------------
#12  $50   Multiple-dimension arrays.  Cost includes only support in
            free-form calcs and Extended-Factor-2 opcodes.
-------------------------------------------------------------------------
#13  $40   Extend special-file support by allowing F-spec keyword
SPECIAL
            for all device types.  For example:

            FkeyedFile if   e           k disk
SPECIAL('MYLIB/MYDRIVER')
            C     key        chain    keyedFile
-------------------------------------------------------------------------
#14   $5   %OFFSET builtin function returns offset of subfield from
            beginning of an overlaid-on subfield (or the DS)
            %OFFSET(fld {: containing_subfield}) where 2nd subf defaults
            to DS.
-------------------------------------------------------------------------
#15  $20   Multiple array element initialization:

            D ARRAY         S           10i 0   dim(5)
                                                inz(%list(1:3:5:7:11))
------------------------------------------------------------------------
#16  $10  Keyword EXTDESC to identify name of externally described
            file that contains file description to be used at compile
            time.
-------------------------------------------------------------------------
#17  $20   Dynamic specification of basing variable:

            D basedchar     s                  1A   based
            D p             s                   *
             /free
                    p->basedchar = '1';
                    (pa(12)+offset)->basedchar = '2';
             /end-free

            Pointer notation required for based vars without basing ptr.
            Basing pointer can be any pointer valued expression.
-------------------------------------------------------------------------
#18  $20   Option *ZEROFILL on %EDITC to include leading zeros in
            edited value.
            Examples:
                  num = -1234.56;    // packed(15,2)
                  %editc(num:'A':*ZEROFILL);  //
"0,000,000,001,234.56CR"
                  %editc(num:'P':*ZEROFILL);  // "-0000000001234.56"
-------------------------------------------------------------------------
#19  $20   Option to edit negative numbers using parentheses.  Option
            *PARENS allowed for edit codes 1-4.  For example:

            num1 = 1234.56;     // packed(15,2)
            num2 = -1234.56;    // packed(15,2)
            %editc(num1:'1':*PARENS); // returns "
1,234.56 "
            %editc(num1:'4':*PARENS); // returns "(        1234.56)"
-------------------------------------------------------------------------
#20  $10   ALIAS name support for data structures.  Alias name is used
            instead of regular name for subfields of externally
            described data structures.
            Example:
              D struct    E DS                 EXTNAME(file:rec:*ALIAS)
-------------------------------------------------------------------------
#21   $5   Optional second parameter on %TRIM, %TRIML, and %TRIMR to
            identify character(s) to trim off of the string.
-------------------------------------------------------------------------
#22  $10   Built-in function %COND(condition:truevalue:falsevalue).
            This BIF evaluates the condition.  If the condition
            evaluates to *ON, the "truevalue" is evaluated and returned.
            Otherwise, the "falsevalue" is evaluated and returned.
            The true and false values must both be the same type.
            For example:

            eval   n = %cond(y = 0 : 0 : x / y)
-------------------------------------------------------------------------
#23  $80   Allow any arbitrary expression as parameter to any H-Spec,
            F-Spec, or D-Spec keyword, provided the expression has a
value
            computable at compile-time.  For example:

            D const        C                    17
            D array1       S               1A   DIM(const+34)
            D array2       S               1A   DIM(%ELEMS(array1)*2)
-------------------------------------------------------------------------
#24  $80   Full null field support.  Fields can be declared as null-
            capable within D-Specs.  The null attribute is maintained
            when assigning null-capable fields.  An exception is issued
            when trying to refer to the value of a field that has a null
            value.
-------------------------------------------------------------------------
#25  $80   Allow procedure names to be overloaded.  Actual procedure to
            call is determined by types and number of parameters.  For
            example, "callp proc(1);" might call real procedure
"procnum"
            and "callp proc('a');" might call real procedure "procchar".
-------------------------------------------------------------------------
#26  $15   /FREE should allow longer than 80 character lines.
-------------------------------------------------------------------------
#27   $5   Allow EXTPGM to be coded without a parameter, defaulting to
            the upper-cased form of the name in column 7.

            D mypgm        PR                   EXTPGM

            A CALLP to "mypgm" would call program '*LIBL/MYPGM'.
-------------------------------------------------------------------------
#28  $20   Extend INDDS to associate a data structure with a specific
            record format.  Syntax would be
INDDS({record-name:}ds-name).
            Multiple indicator data structures would be allowed for one
            file.
-------------------------------------------------------------------------
#29  $20   Allow named data structures bigger than 64k bytes long.  Such
            a data structure would not be allowed to be used as a
            character field.
-------------------------------------------------------------------------
#30  $10   Keyword TEMPLATE to define data structures without
allocating
            storage.Keyword TEMPLATE indicates that the data
structure is
            used only as a base for LIKEDS definitions.

            Like BASED, TEMPLATE data structures do not have storage
            allocated, but unlike BASED, TEMPLATE data structures
can have
            subfields initialized.  The initial values are used when
            defining a data structure using LIKEDS and INZ(*LIKEDS).
-------------------------------------------------------------------------
#31  $20   EVALC move corresponding from one data structure to another.
            Each subfield in the source DS having the same name as a
            subfield in the target DS will be assigned to the target DS.

            If the source subfield is a data structure, the target
            subfield must be a character variable or another data
            structure.  If the target subfield is another data
structure,
            the data structure subfields will be assigned using the
same
            EVALC logic as the main structures.
-------------------------------------------------------------------------
#32  $10   Allow BASED(%ADDR(something)).

            For example:
                D indicators     ds       n    based(%addr(*in))
                D    pf03            3   3n
-------------------------------------------------------------------------
#33  $20   Allow variable offset for data structure subfields. This
would
            allow convenient definition of many of the structures
returned
            by APIs, which have the offset of various sections
defined in
            the structure.

                D ds             ds            based(p)
                D   subf1               10i 0
                D   subf2              100a    offset(subf1)

            This would only be allowed with based data structures or
            parameters. For a qualified data structure or one that has
            LIKEDS used, it could only be a subfield within the same
            structure.
-------------------------------------------------------------------------
#34  $40   Provide support for inlining procedures to improve
performance
            of procedure calls.
-------------------------------------------------------------------------
#35  $20   TIME opcode to provide more precise time.  Currently,
only the
            number of milliseconds is provided.  TIME should provide a
            timestamp result with 6 significant digits to the right
of the
            decimal point.
-------------------------------------------------------------------------
#36  $40   Additional parameter passing mechanisms.

           - REFERENCE(*IN) - Parameter is copied (with conversions if
              necessary) to a compiler generated temp.  Address of temp
              is passed
            - REFERENCE(*OUT) - Address of compiler generated temp is
              passed.  On return, value of temp is copied (and
converted
              if necessary) to parameter passed.
            - REFERENCE(*INOUT) - Both *IN and *OUT.

            These keywords would apply to the procedure prototype.
They
            are not needed on the procedure interface, since parameter
            would look like a normal reference parameter.

            This provides functionality equivalent to Factor 1 and
Factor 2
            on opcode PARM.
-------------------------------------------------------------------------
#37   $5   Option to pass a trimmed string as parameter:
OPTION(*TSTRING)
            works like OPTION(*STRING), but the string is trimmed before
            the call.
-------------------------------------------------------------------------
#38  $15   Allow keyword CONST for variables.  CONST variables can be
            initialized, but not modified.  On procedure calls, they can
            be passed only as CONST or VALUE parameters.
-------------------------------------------------------------------------
#39  $10   Allow date, time and timestamp parameters for %INT and %DEC,
            with an optional format parameter, to allow conversion from
            these types to numeric, in expressions.
-------------------------------------------------------------------------
#40  $15   Add a keyword to tell the compiler to do a level check at
            runtime on an externally-described data structure (EXTNAME
            and LIKEREC).  This would require the file to exist at
runtime.
-------------------------------------------------------------------------
#41  $10   LEAVE-WHEN and ITER-WHEN operation codes.  Conditionally
leave
            or iterate a loop in one statement.

              for i = 1 to 10;
                 leave-when arr(i) = *blanks;
              endfor;

              dou %eof(custfile);
                 read custRec;
                 leave-when %eof;

                 chain (cust_id : city_id) masterRec;
                 iter-when not %found;

                 processCust();
              enddo;
-------------------------------------------------------------------------







======================================================
George N. Farr
iSeries eclipse IDE, iSeries education, and RPG Compilers
Development manager



_______________________________________________
This is the RPG programming on the AS400 / iSeries (RPG400-L) mailing list
To post a message email: RPG400-L@midrange.com
To subscribe, unsubscribe, or change list options,
visit: http://lists.midrange.com/cgi-bin/listinfo/rpg400-l
or email: RPG400-L-request@midrange.com
Before posting, please take a moment to review the archives
at http://archive.midrange.com/rpg400-l.


As an Amazon Associate we earn from qualifying purchases.

This thread ...

Follow-Ups:

Follow On AppleNews
Return to Archive home page | Return to MIDRANGE.COM home page

This mailing list archive is Copyright 1997-2024 by midrange.com and David Gibbs as a compilation work. Use of the archive is restricted to research of a business or technical nature. Any other uses are prohibited. Full details are available on our policy page. If you have questions about this, please contact [javascript protected email address].

Operating expenses for this site are earned using the Amazon Associate program and Google Adsense.