Hallo,
ich habe noch eine Idee für eine Lösung, die auf der Idee beruht, dass, wenn der String in Hex umgewandelt wird, das Vorzeichen im vorletzten Byte gespeichert ist.

Jede Zahl hat einen Hexwert, z.B. 1 = F1, 2 = F2, 9 = F9
Das Vorzeichen wird im letzten Zeichen eingebaut, so dass der Hexwert von 000005843M als Ergebnis F0F0F0F0F0F5F8F4F3D4 hat. Das bedeutet, wenn das vorletzte Byte der Hexsequenz nicht F ist, muss die Zahl negativ sein.

Code:
         ctl-opt main(main) dftactgrp(*no) option(*nounref);                                                            
      //------------------------------------------------------------------//                                            
      //                                                                  //                                            
      // Convert Zoned to Packed from String                              //                                            
      //                                                                  //                                            
      //-----------------                                                 //                                            
      // R.Ross 06.2017 *                                                 //                                            
      //------------------------------------------------------------------//                                            
      // CVTHC - Convert Character to Hex                                 //                                            
      //------------------------------------------------------------------//                                            
                                                                                                                        
         dcl-pr charToHex    extproc('cvthc');                                                                          
                 ##hex       char(100) options(*varsize);                                                               
                 ##chr       char(100) options(*varsize);                                                               
                 ##len       int(10)   value;                                                                            
         end-pr;                                                                                                        
                                                                                                                        
      //------------------------------------------------------------------//                                            
      // Main                                                             //                                            
      //------------------------------------------------------------------//                                            
         dcl-proc Main;                                                                                                 
                                                                                                                        
         dcl-s   p#string    varchar(50);             // String                                                         
         dcl-s   p#number    packed(30:9);            // Number                                                         
                                                                                                                        
           p#string = '000005843M';                                                                                     
                                                                                                                        
           p#number = cvtZonedToPacked(p#string:2);                                                                     
                                                                                                                        
         end-proc;                                                                                                      
      //------------------------------------------------------------------//                                            
      // Convert Zoned to Packed from String                              //                                            
      //------------------------------------------------------------------//                                            
         dcl-proc cvtZonedToPacked;                                                                                     
         dcl-pi *n           like(p#number);                                                                            
                 ##string    like(p#string) const options(*varsize:*trim);                                              
                 ##decimals  uns(5)         const options(*nopass);                                                     
         end-pi;                                                                                                        
                                                                                                                        
         dcl-s   p#number    packed(30:9);            // Number                                                         
         dcl-s   p#string    char(100);               // String                                                         
         dcl-s   p#hex       char(100);               // Hex                                                            
         dcl-s   p#length    uns(10);                 // Length                                                         
                                                                                                                        
           p#string = ##string;                       // String                                                         
           p#length = %len(%trim(p#string));          // StringLength                                                   
                                                                                                                        
           charToHex(p#hex:p#string:p#length * 2);    // Character to Hex                                               
                                                                                                                        
           if %subst(p#hex:(p#length * 2) - 1) = 'F'; // F = Positive Number                                            
              p#number = %dec(%trim(p#string):30:9);  // StringToNumber                                                 
            else;                                     // Negative Number                                                
              %subst(p#string:p#length:1) = %subst(p#hex:p#length * 2:1);                                               
              p#string = %trim(p#string) + '-';       // Negative Sign                                                  
              p#number = %dec(%trim(p#string):30:9);  // StringToNumber                                                 
           endif;                                                                                                       
                                                                                                                        
           if %parms >= %parmnum(##decimals);         // Decimals                                                       
              p#number /= 10 ** ##decimals;           // Decimals                                                       
           endif;                                                                                                       
                                                                                                                        
           return p#number;                           // Number                                                         
                                                                                                                        
         end-proc;                                                                                                      
      //------------------------------------------------------------------//
Herzliche Grüße
Rainer