Serie ficheros virtuales

 

 

 

 

C Ficheros virtuales

 

 

 

 

 

A.I.9 Alternativa RPG. El programa de servicio SRAGM

 

 A.I.9.0 Introducción

 A.I.9.1 Presentación de SRAGM

 A.I.9.2 Implementación

 A.I.9.3 Tipología de los parámetros

 A.I.9.4 SRAGF_ACU. La versión RPG de SRRCS_ACU

 

                                                                                             _______

 

A.I.9.0 Introducción

 

Este capítulo es un guiño a los usuarios iSeries. Parece justo pues SRRCW nació para ser utilizado en esta plataforma, sin embargo es más fácil hacer un libro para la plataforma PC que admite dedicación y desarrollos particulares frente a la orientación empresarial de la plataforma iSeries.

 

Se ha procurado que pueda leerse con facilidad por usuarios de PC, por lo que para un usuario de iSeries la presentación puede resultar muy simplificada, la alternativa, una presentación y estudio detallado de los mecanismos que se han presentado para C ANSI en este libro para RPG, es objeto del subdominio iSeries.ficherosvirtuales.com

 

En este subdominio se pormenoriza más allá de la simple introducción que se hace en este capítulo del blog en curso, que forma parte a su vez de la serie www.ficherosvirtuales.com, en la que se irán introduciendo implementaciones paralelas de los ficheros virtuales en distintos lenguajes como Cnet, VBA o JavaScript.

 

 

                                                                                             _______

 

 

A.I.9.1 Presentación de SRAGM

 

SRAGM es un acrónimo de SR = Servicio de AG = Aplicación General de M = Memoria virtual

 

SRAGM es un interfaz a SRRCW implementado como programa de servicio ILE-RPG para plataforma iSeries con el objetivo de ser el interfaz a utilizar por otros programas ILE-RPG en vez del propio SRRCW, pues soporta la sobrecarga multifunción.

 

Además, emplea un fichero virtual adicional para conservar información extra de cada fichero virtual generado, en concreto con la información  sobre trabajo-fecha-hora-pila de programas que puede explotarse para propósito de seguimiento y estadística.

 

 

                                                                                             _______

 

A.I.9.2 Implementación

 

Para ver el funcionamiento concreto, estudiaremos en detalle uno de los interfaces implementados en SRAGM:  SRAGM_CHAIN, dedicado al acceso directo por clave o "chain".

 

Para este objetivo conviene decir que el actual código RPG ILE en formato FREE es muy similar al C en las instrucciones de cálculo, y aunque difiere por completo en las especificaciones de definición, éstas se han comentado de forma que puedan seguirse también desde una perspectiva C ANSI.

 

 

                                                                                             _______

 

 

Comencemos entonces a presentar las diferentes partes del módulo SRAGM_CHAIN:

 

 

Parámetros

 

Para el módulo que vamos a ver ahora, la definición del prototipo con parámetros opcionales equivalente en C sería

 

 

      long SRAGM_CHAIN(const char *cFILE, char *cCLAV, ...);

 

 

 

Que en RPG se codifica siguiendo un formato más explícito como sigue

 

      *           PPPPPPPPPPPPPPPPPPPPPPPPPPPPPP

      *        PPPPPP                        PPPPPP

      * SRAGM_CHAIN: Recupera un registro de un fichero virtual

      *        PPPPPP                        PPPPPP

      *           PPPPPPPPPPPPPPPPPPPPPPPPPPPPPP

      *

     PSRAGM_CHAIN      B                   EXPORT

      *

     DSRAGM_CHAIN      PI            10I 0                                      PosiciónItem/0=Error

     D P_pFILE                         *   VALUE OPTIONS(*STRING)               Nombre Fichero   1*I   (*)

     D P_pCLAV                         *   VALUE OPTIONS(*STRING)               pCLAVE solicitada2*I

     D P_pDATO                         *   VALUE OPTIONS(*NOPASS)               pDATOS pedidos(O)3*I   (**)

     D P_LONG                        10I 0 VALUE OPTIONS(*NOPASS)               LongtdClvParcial 4*I

 

 

 

Definiciones

 

 

El equivalente de las sentencias de definición que vamos a ver sería en C como sigue:

 

 

 

// Valor de retorno

 

long T_Resu;

 

 

// Control de paso opcional de parámetros

 

long T_parms;

 

 

 

 

En RPG se codifica como

 

      ***

      * * CAMPOS DE TRABAJO E INDICADORES

      ***

      *

      * Valor de retorno

     D T_Resu          S             10I 0

      *

      * Paso opcional de parámetros

     D T_parms         S             10I 0

 

                                                                                             _______

 

 

Especificaciones de cálculo

 

SRAGM es un interfaz de las funciones de SRRCW para facilitar el uso de los ficheros virtuales desde programas RPG, este hecho va a quedar de manifiesto a continuación puesto que sus instrucciones se reducen a controlar el número de parámetros recibido y llamar a la versión de SRRCW asociada.

 

Esta versión es algo diferente de la presentada en los capítulos anteriores, se trata de la versión específica para iSeries que sigue un código C ANSI estricto y prescinde de la sobrecarga. Este fuente puede consultarse en SRRCWH, en SRRCW y en PSRRCW.

 

 

En cuanto a la propia codificación de cálculo, es similar en C y en ILE-RPG FREE, como puede apreciarse en el cuerpo del código de la rutina que sigue ahora:

 

 

      /FREE

 

 

         // Proceso para nº de parámetros limitado

 

         T_parms = %parms();

 

 

         select;

 

 

            // Proceso limitado a 2 parámetros

 

            when T_parms <= 2;

 

               T_Resu = SRRCW_CHAINR(P_pFILE:P_pCLAV);

               return T_Resu;

 

 

            // Proceso limitado a 3 parámetros

 

            when T_parms <= 3;

 

               T_Resu = SRRCW_CHAIN(P_pFILE:P_pCLAV:P_pDATO);

               return T_Resu;

 

         endsl;

 

 

 

         // Proceso para nº de parámetros completo

 

         T_Resu = SRRCW_CHAINE(P_pFILE:P_pCLAV:P_pDATO:P_Long);

         return T_Resu;

 

 

 

 

      /END-FREE

 

 

     PSRAGM_CHAIN      E

 

                                                                                             _______

 

 

A.I.9.3 Parámetros opcionales

 

(*) La codificación de las opciones no tiene una traducción directa a C ANSI porque es más versátil en ILE-RPG, pero 

    puede decirse lo siguiente:

 

VALUE es "paso por valor", en este contexto significa que el puntero, como tal, no se cambiará; el contenido apuntado, sin embargo, tomará el nuevo valor recuperado.

 

OPTIONS(*STRING) indica que puede recibirse un puntero o un char al que el sistema proporcionará un puntero temporal de paso.

 

OPTIONS(*NOPASS) indica que el parámetro es opcional.

 

(**) Según interese, la clave y los datos pueden solicitarse de forma conjunta o separada; lo más cómodo es definir una estructura de

     fichero virtual que incluya una primera parte de clave y a continuación una de datos, con lo que sólo se necesitaría definir un único

     puntero para pasar/recibir claves y datos

 

 

                                                                                             _______

 

 

A.I.9.4 SRAGF_ACU, la versión RPG de SRRCFS_ACU

 

Para ver un ejemplo de aplicación, veamos la rutina de ejemplo SRRCFS_ACU que vimos antes, rescrita como un procedimiento de un programa de servicio en RPG utilizando las instrucciones SRGAM_NEW, SRAGM_CLRF, SRAGM_WRITE, SRAGM_CHAIN, SRAGM_UPDATE y SRAGM_READ.

 

Después de la zona de definición de parámetros y campos de trabajo a la que sería de aplicación los comentarios anteriores para su interpretación por parte de un lector no familiarizado con el RPG, aparece la zona de código que es de un aspecto similar al que se utilizó para C anteriormente:

 

 

Parámetros:

 

* SRAGF_ACU: Acumula importes por fechas

 

PSRAGF_ACU B EXPORT

*

DSRAGF_ACU PI 10I 0 // Dimensión de salida

D P_NSF 10I 0 VALUE // Dimensión de entrada

D P_pSF * VALUE     // Puntero a serie de fechas

D P_pSI * VALUE     // Puntero a serie de importes

 

 

 

Definiciones:

 

***

* * CAMPOS DE TRABAJO E INDICADORES

***

*

* Paso de dimensión de salida

D T_NSFO S 10I 0 // Dimensión de salida

*

* Series basadas en los punteros recibidos

D SF S 8B 0 DIM(32767) BASED(P_pSF) // Serie de fechas (*)

D SI S 8F   DIM(32767) BASED(P_pSI) // Serie de importes

*

* Variables para SRRCW

D T_Erro S 10I 0  // Control de errores

D T_I    S 10I 0  // Contador de for

D T_Nid  S 10I 0  // Identificador de DSACU

D T_Resu S 10I 0  // Control de resultados

 

***

* * DS del fichero virtual soporte del proceso (**)

***

D DSACU DS BASED(pDSACU) QUALIFIED

D  DSK LIKEDS(DSCCk) // Parte de clave

D  DSD LIKEDS(DSCCd) // Parte de datos

 

***

* * DS de claves

***

D DSCCk BASED(pDSCCk) QUALIFIED

D  CCFECH 8B 0 // Fecha fmt AMD

 

***

* * DS de datos

***

D DSCCk BASED(pDSCCk) QUALIFIED

D  CCIMPT 8F // Importe

 

 

 

Especificaciones de cálculo:

 

 

/FREE

 

 

// Filtro

 

if (P_NSf <= 1) return P_NSF;

 

 

// Limpia o genera el fichero virtual

 

 T_Nid = SRRCW_NOW('DSACU': %size(DSACU.DSK): %size(DSACU));

 if T_Nid = *ZEROS;

   return P_NSF;

 endif;

 

 

 

// Bucle de acumulación

 

for T_I = 1 to P_NSF;

 

 

 // Pasa campos del formato de registro del fichero virtual de proceso

 

  DSACU.DSK.CCFECH = SF(T_I);

  DSACU.DSD.CCIMPT = SI(T_I);

 

 

  // Graba o actualiza registros en el fichero virtual de soporte

 

  T_Resu = SRRCW_WRITE('DSACU': %addr(DSACU));

 

 

  // Si graba, progresa el contador de salida

 

  if (T_Resu > *ZEROS)

  T_NSFO += 1;

 

 

  // En caso contrario, accede al contenido y lo actualiza

 

  else;

 

 

   // Accede

 

   T_Resu = SRAGM_CHAIN('DSACU': %addr(DSACU));

 

 

   // Acumula y actualiza

 

   DSACU.DSD.CCIMPT += SI(T_I);

 

   T_Resu = SRAGM_UPDATE('DSACU': %addr(DSACU));

  

 

  endif;

 

endfor;

 

 

 

// Bucle de volcado de resultados

 

for T_I = 1 to T_NSFO;

 

  T_Erro = SRAGM_READ('DSACU': T_I: %addr(DSACU));

   

  SF(T_I) = DSACU.DSK.CCFECH;

  SI(T_I) = DSACU.DSD.CCIMPT;

 

endfor;

 

 

// Sale la dimensión obtenida

 

return T_NSFO;

 

 

 

// Monitorización de errores

 

begsr *PSSR;

 

   SRAGG_AnotPSSR(P1STAT);

   return *ZEROS;

 

endsr;

 

 

/END-FREE

 

 

PSRAGF_ACU E

 

 

(*) La dimensión máxima de 32767 es un soporte ficticio, la verdadera dimensión

       la establece el programa de llamada utilizando DIM o %alloc

 

(**) Aunque aquí se presentan como estructuras internas explícitas, es recomendable poner las estructuras que se

         empleen para definir cada fichero virtual en fuentes separadas a incluir por /COPY

         a fin de mejorar el mantenimiento; esta recomendación prácticamente se convierte en

         exigencia cuando los ficheros se comparten entre varios programas

 

                                                                                             _______