Buenas.
Pues sí que has aclarado. era yo que lo estaba haciendo mal. 
En las funciones, se define el parámetro a nivel de componente y se pone 
el EXPORT:
P Fun021i         B                   EXPORT 
D Fun021i         PI             8  0 
 Pues yo me había empeñado en no poner tampoco el EXPORT cuando no había 
que definir el parámetro, (como cuando retorna más de un valor).
P Fun022i         B 
D Fun022i         PI 

Salu2 y gracias



De:     Javier Mora <[email protected]>
Para:   "'forum.help400'" <[email protected]>
Fecha:  18/08/2015 11:06
Asunto: RE: Procedimientos en programas de servicio
Enviado por:    [email protected]



No he entendido muy bien tu problema. A modo de resumen, RPG no entiende o 
distingue entre funciones o procedimientos, todo son subprocedimientos. 
Nosotros podemos diferenciarlos como: funciones o procedimientos. 
Realmente, lo único que los diferencia es que las primeras pueden formar 
parte de expresiones.
 
Por ejemplo, una función típico que yo uso frencuentemente es:
 
    /**
     *  IsLeapYear()
     *
     *  Comprobar si el año es bisiesto.
     *
     *  Parámetro      Uso  Descripción
     *
     *  date            E   Una fecha cualquiera.
     *
     *  Valor retorno: *ON si el año es bisiesto.
     *                 *OFF en caso contrario.
     */
 
     P IsLeapYear      B                   Export
     D IsLeapYear      PI              N
     D   date                          D   Const
 
     D year            S             10I 0
      /FREE
 
       year = %Subdt( date: *YEARS );
 
      // Los múltiplos de 100 deben ser divisibles entre 400
       If %Rem( year: 100 ) = 0;
          Return  ( %Rem( year: 400 ) = 0 );
       Else;
          Return  ( %Rem( year: 4 ) = 0 );
       Endif;
       Return  *OFF;
 
      /END-FREE
     P IsLeapYear      E
 
Que me devuelve *ON si el año de la fecha pasada es bisiesto u *OFF en 
caso contrario.
 
Un procedimiento típico en mi instalación podría ser este:
 
    /**
     *  ConvertCase()
     *
     *  Convertir a mayúsculas o minúsculas una cadena de caracteres.
     *
     *  Parámetro      Uso  Descripción
     *
     *  inStr           E   Expresión de tipo cadena para convertir a
     *                      mayúsculas/minúsculas.
     *  inStrSize       E   Tamaño en bytes de la cadena de entrada.
     *  outStr          S   Cadena que recibirá la cadana convertida.
     *  outStrSize      E   Tamaño en bytes de la variable que recibirá
     *                      la cadena convertida.
     *  o_option        E   Tipo de conversión:
     *                      0 = a mayúsculas (valor por defecto)
     *                      1 = a minúsculas
     *  o_ccsid         E   Identificador del juego de caracteres con
     *                      el que está codificada la cadena 'inStr'.
     *
     *  Valor retorno: Ninguno.
     */
 
     P ConvertCase     B                   Export
     D ConvertCase     PI
     D   inStr                             Const Like( TypeBuffer2 )
     D                                           Options( *VARSIZE )
     D   inStrSize                         Const Like( INT4_T )
     D   outStr                                  Like( TypeBuffer2 )
     D                                           Options( *VARSIZE )
     D   outStrSize                        Const Like( INT4_T )
     D   o_option                          Const Like( INT4_T )
     D                                           Options( *NOPASS )
     D   o_ccsid                           Const Like( INT4_T )
     D                                           Options( *NOPASS )
 
     D PARM_OPTION     C                   5
     D PARM_CCSID      C                   6
 
     D rcb             DS                  LikeDs( NLS_reqCtlBlk_ccsid_T )
     D error           DS                  LikeDs( ERRC0100_T )
 
     D minLen          S                   Like( INT4_T )
      /FREE
 
      // Si no se indica el tamaño de la cadena de entrada ni
      // la de destino no es necesario realizar la conversión
      // ni ninguna otra cosa.
       If  inStrSize <= 0 Or outStrSize <= 0;
          //Si interesa, ¡aquí podría lanzarse una excepción!
          Return;
       Endif;
 
      // Si la cadena de entrada sólo contiene blancos, no hay
      // conversión, se devuelven los mismos blancos.
       If  %Subst( inStr: 1: inStrSize ) = *BLANKS;
          %Subst( outStr: 1: outStrSize ) = *BLANKS;
          Return;
       Endif;
 
      // Configurar el bloque de control para la conversión.
       rcb = *ALLx'00';
       rcb.reqType = 1;            // Conversión por CCSID
       If  %Parms() >= PARM_CCSID;
          rcb.ccsid   = o_ccsid;
       Else;
          rcb.ccsid   = 0;         // Usar el CCSID del trabajo
       Endif;
       If  %Parms() >= PARM_OPTION;
          rcb.caseReq = o_option;
       Else;
          rcb.caseReq = STR_TO_UPPER;
       Endif;
 
      // El tamaño más corto de los parámetros determina cuantos
      // caracteres se van a convertir
       minLen = Min( inStrSize: outStrSize );
 
      // Convertir los datos
       Clear  error;
       QlgConvertCase( rcb
                     : %Subst( inStr: 1: minLen )
                     : outStr
                     : minLen
                     : error
                     );
       If  outStrSize > minLen;
          %Subst( outStr: minLen+1: outStrSize-minLen ) = *BLANKS;
       Endif;
       Return;
 
      /END-FREE
     P ConvertCase     E
 
Como puedes ver tiene 6 parámetros y uno es de salida (outStr). En otros 
procedimientos podrían ser más.
 
En ambos casos (función y procedimiento) se define el subprocedimiento 
como EXPORT y también se añaden a la lista de procedimientos exportados 
(tipo de funente BND).
 
Espero haber aclarado un poco tus dudas.
 
Saludos,
 
Javier 
 
De: [email protected] [
mailto:[email protected]] En nombre de alberto
Enviado el: martes, 18 de agosto de 2015 9:18
Para: forum.help400
Asunto: Procedimientos en programas de servicio
 
Buenas. Estoy reorganizando el tema de subprogramas, rutinas o como le 
queramos decir, y estoy haciendo funciones con ellos y creando programas 
de servicio. 
Para las funciones con un valor EXPORT, no hay problema, pero claro, tengo 
muchos subprogramas de estos que me devuelven varios parámetros, vamos, 
que son procedimientos normales, no funciones. Estos no sé cómo meterlos 
(ni si se puede) en programa de servicio, ya que al no tener un campo 
EXPORT no los puedo meter en el fuente *BND. 
No he encontrado ningún ejemplo que lo haga, ni tampoco he encontrado nada 
que me diga que no se puede hacer. 
Me podéis decir si se puede hacer, y en caso afirmativo, cómo? 
Simplemente, crear un programa de servicio con un procedimiento que 
devuelva varios parámetros. 
Gracias____________________________________________________
Únete a Recursos AS400, nuestra Comunidad ( http://bit.ly/db68dd )
Forum.Help400 © Publicaciones Help400, S.L.
____________________________________________________
Únete a Recursos AS400, nuestra Comunidad ( http://bit.ly/db68dd )
Forum.Help400 © Publicaciones Help400, S.L.

Responder a