Adding preceding zeros for a particular field based on value in that field in JCL

Question

I have tried adding preceding zeros to a field in JCL but all idea which I tried are not matching with my requirements. my requirement is to add preceding zeros only if the field is numeric and only if field is having preceding spaces.

Input Sample Input

Expected Output: Sample output

I have already tried a few methods, but didn't meet my requirements.
I have viewed the query Add zero padding to string in JCL but it's not applicable in my case.

Below are what I have tried

Method 1

//STEP0001 EXEC PGM=SORT                                       
//SYSOUT   DD SYSOUT=*                                         
//SYMNAMES DD *                                                
ALPHA,C'A, ,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z' 
//SORTIN   DD *                                                
123457 0                                                       
34567R                                                         
997654D3                                                       
    45833                                                      
23                                                             
//SORTOUT  DD SYSOUT=*                                         
//SYSIN    DD *                                                    
  SORT FIELDS=COPY                                                 
  INREC IFTHEN=(WHEN=(01,01,SS,EQ,ALPHA,OR,02,01,SS,EQ,ALPHA,OR,   
                      03,01,SS,EQ,ALPHA,OR,04,01,SS,EQ,ALPHA,OR,   
                      05,01,SS,EQ,ALPHA,OR,06,01,SS,EQ,ALPHA,OR,   
                      07,01,SS,EQ,ALPHA,OR,08,01,SS,EQ,ALPHA,OR,   
                      09,01,SS,EQ,ALPHA,OR,10,01,SS,EQ,ALPHA),     
  BUILD=(1,10)),                                                   
  IFTHEN=(WHEN=NONE,BUILD=(1,10,UFF,M11,LENGTH=10))                
//

Method 2

//STEP0001 EXEC PGM=SORT                                               
//SYSOUT   DD SYSOUT=*                                                 
//SORTIN   DD *                                                        
123457   0                                                             
34567                                                                  
997654                                                                 
4568 F ABC                                                             
23 1     1                                                             
//SORTOUT  DD SYSOUT=*                                                 
//SYSIN    DD *                                                        
  SORT FIELDS=COPY                                                     
  INREC IFOUTLEN=50,IFTHEN=(WHEN=INIT,OVERLAY=(51:1,10,TRAN=ALTSEQ)),  
  IFTHEN=(WHEN=(51,10,FS,EQ,NUM),OVERLAY=(1:1,10,UFF,M11,LENGTH=10))   
  ALTSEQ CODE=(40F0)                                                   
/*

Method 3

//STEP001  EXEC PGM=SORT                      
//SORTIN DD *                                 
764536 27                                     
0097865432                                    
00065499234                                   
00012342345                                   
12301231233                                   
//SORTOUT DD SYSOUT=*                         
//SYSIN DD *                                  
  OPTION COPY                                 
  INREC BUILD=(1,11,UFF,M11,LENGTH=11)        
//

Note:
- It will be better if we can do it in ICETOOL
- Other sort methords are also fine.

Phil Grigsby · Answer 1 · 2017-05-18T20:45:55.970

Here is a possible solution using SYNCSORT. It may work with DFSORT as well.

Solution modified to check for values containing non-numeric characters or embedded blanks.

The example illustrates a numeric field contained within columns 1 - 5.

"Numeric" is assumed to mean digits 0 - 9 only. Handling signs (+/-) or decimal points would obviously be more complicated.

Also, the large number of control statements required make this solution impractical for very long fields or large numbers of fields.

A much better option, if it is available to you, would be to write a sort exit routine to perform the data validation and zero-padding.

This solution works as follows:

The initial BUILD creates a temporary record containing:

cols 1 - 5 : the data field

cols 6 - 10 : a copy of the data field, which will be padded with leading zeroes

col 11 : a flag to indicate whether the data field is valid numeric (blank) or invalid ('I')

col 12 : a flag to keep track of the data field status, updated as each character is processed. (blank) = all characters processed have been blank; ('N') = a non-blank character has been processed; ('B') = a trailing blank following a non-blank character has been processed.

For each character in the data field, there are five IFTHEN tests:

(1) If the character is neither a blank nor a numeric digit, the invalid flag (col 11) is set to 'I'.

(2) If the character is non-blank, and all characters previously processed have been blank, the status flag (col 12) is set to 'N'.

(3) If the character is blank, and a non-blank character has been processed, the status flag (col 12) is set to 'B'.

(4) If the character is non-blank, and a trailing blank character has been processed, the invalid flag (col 11) is set to 'I' (because the data field contains an embedded blank).

(5) If the character is non-blank, and all characters previously processed have been blank, the blank in the copy of the data (cols 6 - 10) is replaced with a zero.

After all characters have been processed:

If the field is either invalid numeric data, or blank, the output record is built using the original data (cols 1 - 5).

Otherwise, the output record is built using the data that has been padded with leading zeroes (cols 6 - 10).

//STEP1   EXEC PGM=SYNCSORT                                             
//SYSOUT   DD  SYSOUT=*                                                 
//SORTIN   DD  *                                                        
    1                                                                   
   1                                                                    
  1                                                                     
 1                                                                      
1                                                                       
   12                                                                   
  12                                                                    
 12                                                                     
12                                                                      
  123                                                                   
 123                                                                    
123                                                                     
 1234                                                                   
1234                                                                    
12345                                                                   

1 2                                                                     
 1 2                                                                    
  1 2                                                                   
1 23                                                                    
 1 23                                                                   
12 3                                                                    
 12 3                                                                   
    X                                                                   
   X                                                                    
  X                                                                     
 X                                                                      
X                                                                       
   1X                                                                   
  X1                                                                    
 1X                                                                     
1X                                                                      
  12X                                                                   
 12X                                                                    
1X3                                                                     
 12X4                                                                   
X234                                                                    
12X45                                                                   
/*                                                                      
//SORTOUT  DD  SYSOUT=*                                                 
//SYSIN    DD  *                                                        
 SORT FIELDS=COPY                                                       
 INREC IFTHEN=(WHEN=INIT,                                               
       BUILD=(1,5,1,5,C'  ')),                                          
         IFTHEN=(WHEN=(1,1,CH,NE,C' ',AND,1,1,FS,NE,NUM),               
          OVERLAY=(11:C'I'),                                            
                   HIT=NEXT),                                           
           IFTHEN=(WHEN=(1,1,CH,NE,C' ',AND,12,1,CH,EQ,C' '),           
            OVERLAY=(12:C'N'),                                          
                     HIT=NEXT),                                         
             IFTHEN=(WHEN=(1,1,CH,EQ,C' ',AND,12,1,CH,EQ,C'N'),         
              OVERLAY=(12:C'B'),                                        
                       HIT=NEXT),                                       
               IFTHEN=(WHEN=(1,1,CH,NE,C' ',AND,12,1,CH,EQ,C'B'),       
                OVERLAY=(11:C'I'),                                      
                         HIT=NEXT),                                     
                 IFTHEN=(WHEN=(1,1,CH,EQ,C' ',AND,12,1,CH,EQ,C' '),     
                  OVERLAY=(6:C'0'),                                     
                           HIT=NEXT),                                   
         IFTHEN=(WHEN=(2,1,CH,NE,C' ',AND,2,1,FS,NE,NUM),               
          OVERLAY=(11:C'I'),                                            
                   HIT=NEXT),                                           
           IFTHEN=(WHEN=(2,1,CH,NE,C' ',AND,12,1,CH,EQ,C' '),           
            OVERLAY=(12:C'N'),                                          
                     HIT=NEXT),                                         
             IFTHEN=(WHEN=(2,1,CH,EQ,C' ',AND,12,1,CH,EQ,C'N'),         
              OVERLAY=(12:C'B'),                                        
                       HIT=NEXT),                                       
               IFTHEN=(WHEN=(2,1,CH,NE,C' ',AND,12,1,CH,EQ,C'B'),       
                OVERLAY=(11:C'I'),                                      
                         HIT=NEXT),                                     
                 IFTHEN=(WHEN=(2,1,CH,EQ,C' ',AND,12,1,CH,EQ,C' '),     
                  OVERLAY=(7:C'0'),                                     
                           HIT=NEXT),                                   
         IFTHEN=(WHEN=(3,1,CH,NE,C' ',AND,3,1,FS,NE,NUM),               
          OVERLAY=(11:C'I'),                                            
                   HIT=NEXT),                                           
           IFTHEN=(WHEN=(3,1,CH,NE,C' ',AND,12,1,CH,EQ,C' '),           
            OVERLAY=(12:C'N'),                                          
                     HIT=NEXT),                                         
             IFTHEN=(WHEN=(3,1,CH,EQ,C' ',AND,12,1,CH,EQ,C'N'),         
              OVERLAY=(12:C'B'),                                        
                       HIT=NEXT),                                       
               IFTHEN=(WHEN=(3,1,CH,NE,C' ',AND,12,1,CH,EQ,C'B'),       
                OVERLAY=(11:C'I'),                                      
                         HIT=NEXT),                                     
                 IFTHEN=(WHEN=(3,1,CH,EQ,C' ',AND,12,1,CH,EQ,C' '),     
                  OVERLAY=(8:C'0'),                                     
                           HIT=NEXT),                                   
         IFTHEN=(WHEN=(4,1,CH,NE,C' ',AND,4,1,FS,NE,NUM),               
          OVERLAY=(11:C'I'),                                            
                   HIT=NEXT),                                           
           IFTHEN=(WHEN=(4,1,CH,NE,C' ',AND,12,1,CH,EQ,C' '),           
            OVERLAY=(12:C'N'),                                          
                     HIT=NEXT),                                         
             IFTHEN=(WHEN=(4,1,CH,EQ,C' ',AND,12,1,CH,EQ,C'N'),         
              OVERLAY=(12:C'B'),                                        
                       HIT=NEXT),                                       
               IFTHEN=(WHEN=(4,1,CH,NE,C' ',AND,12,1,CH,EQ,C'B'),       
                OVERLAY=(11:C'I'),                                      
                         HIT=NEXT),                                     
                 IFTHEN=(WHEN=(4,1,CH,EQ,C' ',AND,12,1,CH,EQ,C' '),     
                  OVERLAY=(9:C'0'),                                     
                           HIT=NEXT),                                   
         IFTHEN=(WHEN=(5,1,CH,NE,C' ',AND,5,1,FS,NE,NUM),               
          OVERLAY=(11:C'I'),                                            
                   HIT=NEXT),                                           
           IFTHEN=(WHEN=(5,1,CH,NE,C' ',AND,12,1,CH,EQ,C' '),           
            OVERLAY=(12:C'N'),                                          
                     HIT=NEXT),                                         
             IFTHEN=(WHEN=(5,1,CH,EQ,C' ',AND,12,1,CH,EQ,C'N'),         
              OVERLAY=(12:C'B'),                                        
                       HIT=NEXT),                                       
               IFTHEN=(WHEN=(5,1,CH,NE,C' ',AND,12,1,CH,EQ,C'B'),       
                OVERLAY=(11:C'I'),                                      
                       HIT=NEXT),                                       
                 IFTHEN=(WHEN=(5,1,CH,EQ,C' ',AND,12,1,CH,EQ,C' '),     
                  OVERLAY=(10:C'0'),                                    
                           HIT=NEXT),                                   
         IFTHEN=(WHEN=(11,1,CH,EQ,C'I',OR,12,1,CH,EQ,C' '),             
          BUILD=(1,5)),                                                 
         IFTHEN=(WHEN=(11,1,CH,NE,C'I',AND,12,1,CH,NE,C' '),            
          BUILD=(6,5))                                                  
/*

Output:

how is checking that fields is numeric? I see you looking for spaces and replacing them with 0, but I don't see where you check if the input is numeric — SaggingRufus, May 18 '17 at 16:07
You're right; I missed that requirement. Solution updated. Thanks! — Phil Grigsby, May 18 '17 at 20:47

score 0 · Answer 2 · answered May 19 '17 at 12:04

I have found the solution for the question using SORT.

OPTION COPY                                                         
INREC IFTHEN=(WHEN=(13,12,CH,EQ,C' '),OVERLAY=(13:C'000000000000')),
      IFTHEN=(WHEN=(13,11,CH,EQ,C' '),OVERLAY=(13:C'00000000000')), 
      IFTHEN=(WHEN=(13,10,CH,EQ,C' '),OVERLAY=(13:C'0000000000')),  
      IFTHEN=(WHEN=(13,09,CH,EQ,C' '),OVERLAY=(13:C'000000000')),   
      IFTHEN=(WHEN=(13,08,CH,EQ,C' '),OVERLAY=(13:C'00000000')),    
      IFTHEN=(WHEN=(13,07,CH,EQ,C' '),OVERLAY=(13:C'0000000')),     
      IFTHEN=(WHEN=(13,06,CH,EQ,C' '),OVERLAY=(13:C'000000')),      
      IFTHEN=(WHEN=(13,05,CH,EQ,C' '),OVERLAY=(13:C'00000')),       
      IFTHEN=(WHEN=(13,04,CH,EQ,C' '),OVERLAY=(13:C'0000')),        
      IFTHEN=(WHEN=(13,03,CH,EQ,C' '),OVERLAY=(13:C'000')),         
      IFTHEN=(WHEN=(13,02,CH,EQ,C' '),OVERLAY=(13:C'00')),          
      IFTHEN=(WHEN=(13,01,CH,EQ,C' '),OVERLAY=(13:C'0'))

but this doesn't check if the input is numeric which was a requirement of your original question — SaggingRufus, May 19 '17 at 15:32
Yes, it is not validating whether numeric or not. But it works as per my expectation. — E P, May 22 '17 at 13:20
you should probably edit the question to remove that restriction. — SaggingRufus, May 23 '17 at 09:51

Adding preceding zeros for a particular field based on value in that field in JCL

2 Answers2