Hier ein bischen Sourcecode.

Befehl MYCMD
PHP-Code:
             CMD        PROMPT(MYCMD)                        
/* Parameter */                                              
             PARM       KWD(PRM) TYPE(*CHAR) LEN(10) MIN(1) +
                          CHOICE(*PGM) CHOICEPGM(MYCMDPMTR) +
                          PROMPT('Parameter') 
Muss mit dem Parameter VLDCKR(MYCMDCHKR) umgewandelt werden



Programm MYCMDCHKR (Prüfung)
PHP-Code:
/* Programmstart */                                                  
             PGM        PARM(&PRM)                                   
                                                                     
/* Variable deklarieren */                                           
             DCL        VAR(&PRM) TYPE(*CHAR) LEN(10)                
             DCL        VAR(&MSG) TYPE(*CHAR) LEN(132)               
                                                                     
/* Der Parameter ist ungültig */                                     
             IF         COND(&PRM *NE '*VALID1' *AND &PRM *NE +      
                          '*VALID2') THEN(DO)                        
             SNDPGMMSG  MSGID(CPD0006) MSGF(QCPFMSG) MSGDTA('0000 ' +
                          *CAT 'Fehlerhafte Eingabe') MSGTYPE(*DIAG) 
             SNDPGMMSG  MSGID(CPF0002) MSGF(QCPFMSG) MSGTYPE(*ESCAPE)
             ENDDO                                                   
                                                                     
/* Programmende */                                                   
             ENDPGM 

Programm MYCMDPMTR (Bedienerführung)
PHP-Code:
h DftActGrp(*NO) ActGrp(*CALLER)                                                              
 *                                                                                            
 * Prozedurenprototyp für Prozedur 'MYCMDPMTR'                                                
 *                                                                                            
dMYCMDPMTR        PR                                                                          
d                               21A   Const                                --> Parameter 1    
d                             2000A                                        <-- Parameter 2    
 *                                                                                            
 * Prozedurenschnittstelle für Prozedur 'MYCMDPMTR'                                           
 *                                                                                            
dMYCMDPMTR        PI                                                                          
d PIPrm1                        21A   Const                                --> Parameter 1    
d PIPrm2                      2000A                                        <-- Parameter 2    
 *                                                                                            
 *-------------------------------------------------------------------------------------------*
 *                                                                                            
 * Anzahl Werte                                                                               
 *                                                                                            
d                 DS                                                                          
d  ITNbrInt               1      2U 0                                                         
d  ITNbrChar              1      2A                                                           
 *                                                                                            
 * Länge Wert                                                                                 
 *                                                                                            
d                 DS                                                                          
d  ITLenInt               1      2U 0                                                         
d  ITLenChar              1      2A                                                           
 *                                                                                            
 *-------------------------------------------------------------------------------------------*
 *                                                                                            
c                   Select                                                                    
 * Parameter 'PRM' verarbeiten                                                                
c                   When      %Subst(PIPrm1 : 11 : 10) = 'PRM'                                
c                   Select                                                                    
 * Werte zu 'C' erscheinen rechts neben dem Eingabefeld                                       
c                   When      %Subst(PIPrm1 : 21 : 1) = 'C'                                   
 * 'Wert' in 'Parameter 2' einfügen (Maximal 30 Stellen)                                      
c                   Eval      %Subst(PIPrm2 : 1 : 30) = '*VALID1 ...'                         
 * Werte zu 'P' erscheinen wenn F4 gedrückt wird                                              
c                   When      %Subst(PIPrm1 : 21 : 1) = 'P'                                   
 * * * Initialisierung * * *                                                                  
 * 'Parameter 2' initialisieren                                                               
c                   Eval      PIPrm2 = *Blanks                                                
 * 'Anzahl Werte' initialisieren                                                              
c                   Eval      ITNbrInt = *Zero                                                
 * * * Wert '*VALID1' einfügen * * *                                                          
 * 'Anzahl Werte' erhöhen                                                                     
c                   Eval      ITNbrInt = ITNbrInt + 1                              
 * 'Länge Wert' ermitteln                                                          
c                   Eval      ITLenInt = %len('*VALID1')                           
 * 'Länge Wert' und 'Wert' in 'Parameter 2' einfügen                               
c                   Eval      PIPrm2 = %Trim(PIPrm2) +                             
c                                      ITLenChar + '*VALID1'                       
 * * * Wert '*VALID2' einfügen * * *                                               
 * 'Anzahl Werte' erhöhen                                                          
c                   Eval      ITNbrInt = ITNbrInt + 1                              
 * 'Länge Wert' ermitteln                                                          
c                   Eval      ITLenInt = %len('*VALID2')                           
 * 'Länge Wert' und 'Wert' in 'Parameter 2' einfügen                               
c                   Eval      PIPrm2 = %Trim(PIPrm2) +                             
c                                      ITLenChar + '*VALID2'                       
 * * * Abschluss * * *                                                             
 * 'Anzahl Werte' in 'Parameter 2' einfügen                                        
c                   Eval      PIPrm2 = ITNbrChar + PIPrm2                          
c                   EndSl                                                          
c                   EndSl                                                          
 * Programm nicht hauptspeicherresident verlassen                                  
c                   Eval      *INLR = *On 

Zu beachten ist, dass hier die beiden Werte *VALID1 und *VALID2 die einzigen gültigen Werte sind. Es sollte keine Probleme machen das ganze entsprechend nach den eigenen Vorstellungen zu modifizieren. Wichtig ist auch noch, dass die 2000 Bytes im Parameter PIPrm2 nur ein Beispielwert ist. Der kann je nach der Definition des Parameters im Befehlsobjekt auch höher sein.