Desarrollando en Cobol y Natural sobre Plataforma Mainframe

lunes, 26 de octubre de 2015

Comando COMPUTE para Cobol

Como en todos los lenguajes, en Cobol también disponemos de un comando específico que nos permite realizar operaciones matemáticas entre operandos. Eso sí, debido a que nuestro lenguaje no está pensado para su utilización en entornos científicos, en las rutinas que elaboremos sólo podremos incluir operaciones aritméticas sencillas.

Ejecución de operaciones matemáticas en Cobol


Seguro que, en más de una ocasión, os habéis encontrado con una situación en la que el algoritmo de una determinada funcionalidad os ha obligado a implementar alguna operación matemática. Para acometer tareas de este tipo, en lenguaje Cobol disponemos de los comandos ADD, SUBTRACT, MULTIPLY y DIVIDE (sumar, restar, multiplicar y dividir).

Pero, si queremos implementar fórmulas algo más complejas, podemos recurrir al comando COMPUTE. Esta función nos permitiría incluir, en una misma declaración, la ejecución de múltiples operaciones sobre operandos diversos. De este modo, podremos realizar sumas, restas, multiplicaciones y divisiones en la misma sentencia.


Como vemos, se trata de un comando bastante estándar. De hecho, hay varios lenguajes de programación en los que esta función se denomina del mismo modo: COMPUTE. Sin ir más lejos, así ocurre en Natural ADABAS, otro de los lenguajes de los que solemos hablar de vez en cuando en el blog.

¿Cómo se implementa una sentencia COMPUTE?


A continuación vamos a ver un ejemplo de cómo se debería implementar la sentencia COMPUTE dentro de un párrafo de Cobol. Obviamente, el número de combinaciones para esta función es muy elevado pero, para facilitar su explicación, centrémonos en la siguiente fórmula modelo que se compone de 3 operadores y de 8 variables.

DATA DIVISION.
WORKING-STORAGE SECTION.

01 W-PTOS-CALCULADOS           PIC 9(5).

01 W-DISTANCIAS-ABS.                                   
  05 W-REGL-NU-COORDX-DESDE    PIC  9(5)     VALUE ZEROES.
  05 W-REGL-NU-COORDY-DESDE    PIC  9(5)     VALUE ZEROES.
  05 W-PTCO-NU-COORDX-DESDE    PIC  9(5)     VALUE ZEROES.
  05 W-PTCO-NU-COORDY-DESDE    PIC  9(5)     VALUE ZEROES.

  05 W-REGL-NU-COORDX-HASTA    PIC  9(5)     VALUE ZEROES.
  05 W-REGL-NU-COORDY-HASTA    PIC  9(5)     VALUE ZEROES.
  05 W-PTCO-NU-COORDX-HASTA    PIC  9(5)     VALUE ZEROES.
  05 W-PTCO-NU-COORDY-HASTA    PIC  9(5)     VALUE ZEROES.


...

PROCEDURE DIVISION.

COMPUTE  W-PTOS-CALCULADOS  =    
   (W-REGL-NU-COORDX-HASTA -     
    W-REGL-NU-COORDX-DESDE + 1 ) *
   (W-REGL-NU-COORDY-HASTA -     
    W-REGL-NU-COORDY-DESDE + 1 ) *
   (W-PTCO-NU-COORDX-HASTA -     
    W-PTCO-NU-COORDX-DESDE + 1 ) *
   (W-PTCO-NU-COORDY-HASTA -     
    W-PTCO-NU-COORDY-DESDE + 1 ).   


Como se aprecia, en la declaración anterior se están usando 8 variables y 3 operadores aritméticos: suma, resta y multiplicación. De este modo nos evitamos tener que emplear 3 sentencias distintas con los comandos ADD, SUBTRACT y MULTIPLY y, al mismo tiempo, nos ahorramos la definición de algunas variables auxiliares que hubiésemos tenido que utilizar en el caso de no recurrir al comando COMPUTE.


Por lo que respecta a la fórmula en sí misma, entiendo que es muy sencilla y que no hace falta recurrir a ninguna explicación adicional de la misma. Básicamente, se están calculando las diferencias entre varias coordenadas y multiplicando dichas distancias entre sí para obtener un valor denominado "Puntos Calculados" (variable que, una vez visto el ejemplo, ya no tiene interés para nosotros y que se usará posteriormente en el algoritmo del programa Cobol CICS).

Aprendiendo a utilizar el comando COMPUTE


Una vez visto cómo hemos realizado la declaración en nuestro ejemplo, no deberíais tener problemas a la hora de extrapolar su empleo a vuestros propios programas. Se trata de un comando estándar cuya utilización es bastante intuitiva y, según mi experiencia, no suele causar demasiadas dificultades a los programadores principiantes.

Por si acaso, y teniendo en cuenta que un ejemplo práctico vale más que 1.000 palabras de teoría, a continuación paso a incluir algunas sentencias más con posibles usos del comando. A partir de ellos, se pueden elaborar otras 1.000 variantes diferentes, de manera que no vamos a tener problemas para encontrar la opción que encaje con el que requiera nuestro algoritmo.

COMPUTE W-TOTAL-1 = W-OPERANDOS-1 + W-OPERANDOS-2

COMPUTE W-TOTAL-2 = W-OPERANDOR-1 - W-OPERANDOR-2

COMPUTE W-TOTAL-3 = W-OPERANDOM-1 * W-OPERANDOM-2

COMPUTE W-TOTAL-4 = W-OPERANDOD-1 / W-OPERANDOD-2

COMPUTE W-TOTAL-5 = (W-OPERANDOSD-1 + W-OPERANDOSD-2) / (W-OPERANDOSD-3 - W-OPERANDOSD-4)

COMPUTE W-TOTAL-6 = (W-OPERANDODM-1 / W-OPERANDODM-2) * (W-OPERANDODM-3 / W-OPERANDODM-4)

COMPUTE W-TOTAL-7 = (W-OPERANDORD-1 - W-OPERANDORD-2) / W-OPERANDORD-3

COMPUTE W-TOTAL-8 = (W-OPERANDOSM-1 + 1) * (W-OPERANDOSM-2 / W-OPERANDOSM-3) * ((W-OPERANDOSM-4 - W-OPERANDOSM-5) / W-OPERANDOSM-6)

Como vemos, las construcciones con COMPUTE se pueden ir incrementando de dificultad de forma indefinida. Esto nos va a facilitar la incorporación de la complejidad requerida a nuestras fórmulas, siempre y cuando no nos salgamos del catálogo de operaciones aritméticas básicas. En mi propia experiencia, el comando COMPUTE es más que suficiente para implementar la mayoría de las fórmulas requeridas en los algoritmos de los programas Cobol CICS DB2.


En definitiva, tenemos que considerar al COMPUTE como una sentencia de elaboración de fórmulas aritméticas que nos va a permitir ahorrar tiempo y código a la hora de desarrollar. Por un lado, su uso nos permitirá sustituir a los comandos ADD, SUBTRAC, MULTIPLY y DIVIDE; por otro lado, reduciremos el número de variables auxiliares precisadas para operar.

Y eso es todo por hoy. Espero que lo comentado os sirva para resolver todas las dudas que tengáis acerca del comando COMPUTE y que os facilite vuestra labor con el cliente. De todas formas, ya sabéis que podéis dejarme cualquier comentario aquí abajo y os lo responderé lo antes posible...

Saludos.

lunes, 19 de octubre de 2015

Visualizar Fichero comprimido en ISPF

En general, la visualización del contenido de un fichero secuencial con formato estándar no suele tener ninguna complejidad asociada. Sin embargo, se requiere algo más de esfuerzo para poder observar los ficheros cuyos registros contienen campos comprimidos. A continuación, vamos a ver cómo hacerlo.

Ficheros secuenciales con datos empaquetados


Cuando trabajamos con ficheros secuenciales, lo normal es que los registros de los mismos vayan con formato numérico o alfanumérico no comprimido, ya que es el tipo que suele ser más fácil de manejar. Sin embargo, en ocasiones, la necesidad de ahorro de espacio nos puede obligar a trabajar con ficheros con datos en formato empaquetado (COMP-3). La visualización de la información no se realizará del mismo modo en un caso o en otro.

Para tener clara esta diferencia podemos mostrar unos ejemplos. Vamos a acceder al contenido de los ficheros JJPR.UNLOAD.X0005X.POBL y JJPR.UNLOAD.X0005X.POBL2. El primero de ellos está en formato alfanumérico y el segundo contiene algunos campos con formato comprimido COMP-3.



Los registros del fichero alfanumérico son los siguientes (JJPR.UNLOAD.X0005X.POBL).

=COLS> ----+----1----+----2----+----3----+----4    
****** ***************************** Top of Data ***
000001 A-000020-MADRID.................MAD00100    
000002 B-000019-CIUDAD REAL............CRE00200    
000003 A-000018-BARCELONA..............BAR00300    
000004 A-000017-VALENCIA...............VAL00400    
000005 A-000015-ZARAGOZA...............ZAR00600    
000006 B-000014-CASTELLON..............CAS00700    
000007 B-000012-GRANADA................GRA00900    
000008 B-000011-TOLEDO.................TOL01000    
000009 B-000010-SEGOVIA................SEG01100    
000010 B-000002-ALMERIA................ALM01300    
000011 B-000004-SANTANDER..............SAN01500    
000012 B-000005-TARRAGONA..............TAR01600    
000013 B-000006-BADAJOZ................BAD01700    
000014 B-000007-SALAMANCA..............SAL01800    
000015 B-000008-BURGOS.................BUR01900    
=COLS> ----+----1----+----2----+----3----+----4      
****** **************************** Bottom of Data ***


En cambio, el contenido del fichero empaquetado tiene el siguiente aspecto (JJPR.UNLOAD.X0005X.POBL2).

=COLS> ----+----1----+----2----+----3----+--       
****** ***************************** Top of Data ***
000001 A-    -MADRID.................MAD
000002 B-   æ-CIUDAD REAL............CRE
000003 A-   ð-BARCELONA..............BAR
000004 A-   @-VALENCIA...............VAL 
000005 A-   *-ZARAGOZA...............ZAR  -
000006 B-   <-CASTELLON..............CAS  ø
000007 B-    -GRANADA................GRA  °
000008 B-    -TOLEDO.................TOL
000009 B-    -SEGOVIA................SEG
000010 B-    -ALMERIA................ALM
000011 B-   <-SANTANDER..............SAN  &
000012 B-   *-TARRAGONA..............TAR  -
000013 B-   %-BADAJOZ................BAD  ø
000014 B-   @-SALAMANCA..............SAL  Ø
000015 B-   ð-BURGOS.................BUR  °
=COLS> ----+----1----+----2----+----3----+--         
****** **************************** Bottom of Data *** 


Como vemos, los registros del primer fichero son perfectamente legibles sin ninguna acción adicional. Sin embargo, el contenido del segundo fichero aparece con caracteres extraños (formato empaquetado), haciendo imposible identificar los códigos almacenados en sus registros.


¿Cómo visualizar un fichero comprimido?


A continuación, vamos a ver qué es lo que debería hacerse para visualizar el contenido de un fichero comprimido. Se trata de algo muy sencillo pero que, si no conocemos, nos provocará bastantes quebraderos de cabeza al enfrentarnos con campos COMP-3.

Lo que debemos hacer es lo siguiente. En primer lugar, realizamos la apertura del fichero desde la herramienta ISPF. Posteriormente, nos situamos en la línea de comandos COMMAND e introducimos la sentencia HEX ON (activar hexadecimal).

EDIT       JJPR.UNLOAD.X0005X.POBL2         
Command ===> HEX ON                                
=COLS> ----+----1----+----2----+----3----+--    


A continuación, pulsamos INTRO y la utilidad pasará a mostrarnos el contenido de los campos comprimidos en COMP-3.

=COLS> ----+----1----+----2----+----3----+--       
****** ***************************** Top of Data ***
000001 A-    -MADRID.................MAD      
       C600006DCCDCC44444444444444444DCC0010      
       10002C0414994BBBBBBBBBBBBBBBBB414000C      
---------------------------------------------------
000002 B-   æ-CIUDAD REAL............CRE      
       C600096CCECCC4DCCD444444444444CDC0020      
       20001C039441409513BBBBBBBBBBBB395000C      
---------------------------------------------------
000003 A-   ð-BARCELONA..............BAR      
       C600086CCDCCDDDC44444444444444CCD0030      
       10001C0219353651BBBBBBBBBBBBBB219000C      
---------------------------------------------------
000004 A-   @-VALENCIA...............VAL        
       C600076ECDCDCCC444444444444444ECD0040      
       10001C051355391BBBBBBBBBBBBBBB513000C      
000005 A-   *-ZARAGOZA...............ZAR  -       
       C600056ECDCCDEC444444444444444ECD0060       
       10001C091917691BBBBBBBBBBBBBBB919000C       
----------------------------------------------------
000006 B-   <-CASTELLON..............CAS  ø       
       C600046CCEECDDDD44444444444444CCE0070       
       20001C0312353365BBBBBBBBBBBBBB312000C       
----------------------------------------------------
000007 B-    -GRANADA................GRA  °       
       C600026CDCDCCC4444444444444444CDC0090       
       20001C07915141BBBBBBBBBBBBBBBB791000C       
----------------------------------------------------
000008 B-    -TOLEDO.................TOL       
       C600016EDDCCD44444444444444444EDD0000       
       20001C0363546BBBBBBBBBBBBBBBBB363010C       
----------------------------------------------------
000009 B-    -SEGOVIA................SEG       
       C600006ECCDECC4444444444444444ECC0010       
       20001C02576591BBBBBBBBBBBBBBBB257010C       
----------------------------------------------------
000010 B-    -ALMERIA................ALM       
       C600026CDDCDCC4444444444444444CDD0030       
       20000C01345991BBBBBBBBBBBBBBBB134010C       
----------------------------------------------------
000011 B-   <-SANTANDER..............SAN  &       
       C600046ECDECDCCD44444444444444ECD0050       
       20000C0215315459BBBBBBBBBBBBBB215010C       
----------------------------------------------------
000012 B-   *-TARRAGONA..............TAR  -       
       C600056ECDDCCDDC44444444444444ECD0060       
       20000C0319917651BBBBBBBBBBBBBB319010C       
----------------------------------------------------
000013 B-   %-BADAJOZ................BAD  ø       
       C600066CCCCDDE4444444444444444CCC0070       
       20000C02141169BBBBBBBBBBBBBBBB214010C       
----------------------------------------------------
000014 B-   @-SALAMANCA..............SAL  Ø       
       C600076ECDCDCDCC44444444444444ECD0080       
       20000C0213141531BBBBBBBBBBBBBB213010C       
----------------------------------------------------
000015 B-   ð-BURGOS.................BUR  °       
       C600086CEDCDE44444444444444444CED0090       
       20000C0249762BBBBBBBBBBBBBBBBB249010C       
----------------------------------------------------
****** **************************** Bottom of Data ***
=COLS> ----+----1----+----2----+----3----+--


Como vemos, ahora bajo cada registro comprimido original se muestran otros dos registros adicionales. En ellos aparece decodificada la información correspondiente a los campos hexadecimales.


Decodificación de campos hexadecimales

  
Por ejemplo, este es el registro original (no comprimido) correspondiente a MADRID.

000001 A-000020-MADRID.................MAD00100     

Ahora se corresponde con estos 3 registros.

----------------------------------------------------
000001 A-    -MADRID.................MAD      
       C600006DCCDCC44444444444444444DCC0010      
       10002C0414994BBBBBBBBBBBBBBBBB414000C 

----------------------------------------------------


He marcado en rojo la decodificación realizada de los dos campos hexadecimales que contienen los registros de este fichero. El primero es el código interno, 000020, y el segundo es el código externo, 00100. El código interno aparece decodificado como:

0000
002C

Si leemos las líneas anteriores ordenadas de arriba a abajo y de izquierda a derecha, entonces el campo se correspondería con el siguiente número:

0000020C

Donde los 6 dígitos marcados se corresponden con el código interno original, en formato no comprimido 000020.


Del mismo modo, el código externo aparece decodificado como:

0010
000C

Si los leemos ordenados de arriba a abajo y de izquierda a derecha se corresponderían con el siguiente número:

0000100C

Al igual que en el caso anterior, los 5 dígitos marcados se corresponden con el código externo original, en formato no comprimido 00100.

Visualización de ficheros comprimidos en ISPF


Por tanto, podemos ver como el uso del comando HEX ON nos permite acceder a la decodificación numérica de los campos comprimidos de los registros afectados. Con esta sencilla operación evitaremos perder mucho tiempo tratando de descifrar el contenido de los campos hexadecimales.


Si ya conocíais esta forma de visualizar los ficheros comprimidos desde ISPF, entonces este post os habrá parecido superfluo. Sin embargo, debéis tener en cuenta que hay muchos programadores principiantes que, un buen día, se enfrentan con su primer fichero comprimido y en ese momento no saben cómo proceder para leer los datos de los registros. A ellos está dedicado este texto.

Pues nada, eso es todo por hoy. Espero que lo comentado os haya servido para aprender algo nuevo y, lo más importante, que os valga para agilizar vuestro trabajo cotidiano.

Saludos.

lunes, 12 de octubre de 2015

Buscar varios Ficheros a la vez en ISPF (y 2)

Hace algunas semanas comenzamos a ver cómo se podían buscar (y editar) varios ficheros a la vez desde la herramienta ISPF. Se trata de una opción que nos puede facilitar mucho las cosas en el día a día, ya que no es lo mismo poder realizar una búsqueda múltiple que tener que ir accediendo a todos los ficheros uno a uno.

En la primera parte del post vimos un ejemplo de búsqueda simple y, además, hicimos un esbozo de qué es lo que se entiende por editar varios ficheros a la vez (ver post Buscar varios ficheros a la vez en ISPF - 1). Hoy vamos a entrar en detalle y procederemos a examinar los dos casos modelo que cubrirán el 90% de nuestras necesidades a este respecto.

¿Cómo podemos editar varios ficheros a la vez en ISPF?


El caso de búsqueda simple que mostramos anteriormente nos sirve si queremos acceder a un único fichero y si, además, conocemos el nombre del mismo. Pero, ¿qué pasaría si quisiéramos visualizar el contenido de varios ficheros (cuyos nombres tengan alguna cadena de caracteres en común)? ¿Y qué pasaría si no conociésemos el nombre completo del fichero buscado?

Caso 1: Editar varios ficheros a la vez en ISPF


Imaginemos, en primer lugar, que en nuestra aplicación queremos ir viendo el contenido de varios ficheros generados por un determinado proceso que realiza la tramitación de Tarjetas (TARJ). Esta fase JCL genera múltiples datasets con distintos nombres y sabemos que en todos ellos va a figurar la cadena de texto TARJ.

Entonces, en vez de ir poniendo el nombre de cada uno de los ficheros y accediendo a su contenido uno a uno, lo óptimo sería introducir la cadena de texto común en el campo DSNAME LEVEL de la herramienta ISPF. En nuestro caso, podríamos incluir el texto ASTR.A801.*.**.*TARJ*.



Al pulsar INTRO se nos van a mostrar todos los ficheros cuyo nombre cumpla con las condiciones introducidas anteriormente.



Como vemos, se han obtenido todos los datasets que comienzan por “ASTR.A801”  y que tienen la cadena de texto “TARJ” en alguna posición de su denominación. En total, tenemos 7 ficheros y nos hemos ahorrado el trabajo de tener que ir editando cada uno de ellos por separado.

Caso 2: Editar un fichero sin conocer el nombre exacto


Imaginemos ahora, en segundo lugar, que queremos editar un fichero del que no recordamos su nombre exacto. Sabemos que se trata de un fichero de Incidencias y que en el sexto bloque de su denominación figura la cadena de texto “INCI”. De manera análoga al primer caso, aquí podríamos incluir en el campo DSNAME LEVEL del ISPF el texto ASTR.A801*.*.*.*.INCI*.


Al pulsar INTRO se nos va a mostrar el fichero (o ficheros) cuyo nombre cumple con las condiciones introducidas anteriormente.


Como se observa, en la pantalla han aparecido todos los datasets que comienzan por “ASTR.A801”  y que tienen la cadena de texto “INCI” en el sexto bloque de su denominación. En total, tenemos 7 ficheros. Sin lugar a dudas, el fichero de Incidencias que buscamos será uno de ellos y lo hemos encontrado sin necesidad de recordar su nombre completo.

Una vez visto estos dos ejemplos, creo que no hace falta hacer mucho más hincapié en el considerable ahorro de tiempo que supondrá el uso de las búsquedas múltiples. Y lo mejor de todo es que el procedimiento es bastante fácil de recordar, siempre y cuando no hayan transcurrido más de 5 años desde la última vez que lo pusimos en práctica (como le pasó a mi compañero)…


Conclusiones acerca de la edición múltiple de ficheros del ISPF


Si estamos buscando un fichero determinado y nos sabemos su denominación exacta, en general haremos uso de la edición simple del Data Set List Utility de la utilidad ISPF. En este caso, bastará con introducir el nombre completo en el campo DSNAME LEVEL y la herramienta nos mostrará el fichero indicado.

Sin embargo, en los casos en que queramos editar varios ficheros a la vez (o si simplemente no recordamos el nombre completo de nuestro dataset) no nos quedará más remedio que hacer uso de la edición múltiple de la utilidad. Esto se conseguirá introduciendo el carácter “*” (asterisco) en las posiciones requeridas del texto introducido en el campo DSNAME LEVEL, tal y como se ha explicado en los ejemplos comentados a lo largo del artículo.

Obviamente, se trata de una funcionalidad muy simple y con la que se obtiene un considerable ahorro de tiempo a largo plazo. Si no sabíais hacer la edición múltiple, lo más probable es que, una vez leído este post, probéis a lanzar la búsqueda en ISPF por primera vez y ya nunca más tengáis necesidad de volver a consultar cómo se hace. Las cosas sencillas no suelen olvidarse con facilidad…


Os comento esto porque fue precisamente lo que me sucedió a mí. Al principio, cuando empecé a programar en Cobol y a trabajar en el entorno ISPF, no sabía cómo hacer una búsqueda múltiple de ficheros y tuve que pedir ayuda a un compañero. Desde entonces, ya no he tenido que volver a preguntarlo nunca más (y ahora incluso ya está escrito en el blog).

Pues nada, no queda mucho más que contar con respecto a la utilidad Data Set List Utility de ISPF. Si tenéis alguna duda al respecto, ya sabéis que podéis dejarla en el apartado de comentarios y trataré de responderos lo antes posible.

Saludos.

lunes, 5 de octubre de 2015

Buscar varios Ficheros a la vez en ISPF (1)

Del mismo modo que todo el mundo sabe cómo buscar un fichero secuencial en el entorno ISPF, esta herramienta también nos ofrece la posibilidad de buscar varios ficheros a la vez. Y lo que es mejor, ni siquiera tendremos que conocer el nombre completo de los datsets para poder ejecutar dicha búsqueda.

Búsqueda múltiple de ficheros en ISPF


En general, cuando accedemos a la opción Data SetList Utility de ISPF, lo hacemos con la idea de buscar un fichero concreto (o una librería específica) y visualizar su contenido. Sin embargo, esta utilidad también nos permite lanzar una búsqueda múltiple de varios ficheros, siempre y cuando compartan una determinada cadena de caracteres.

Esto nos va a permitir, por un lado, listar varios ficheros (cuyas denominaciones tengan un fragmento en común) sin necesidad de ir introduciendo uno a uno el nombre de todos ellos. Y, por otro lado, nos va a dar la posibilidad de buscar un fichero a partir de una cadena de texto sin necesidad de tener que recordar su nombre exacto.


Esta funcionalidad es sencilla y nos puede parecer una nimiedad. Y en realidad lo es. Pero probablemente no sepamos cómo hacerlo si somos programadores novatos o si hace muchos años que no programamos con lenguaje Cobol (o que no usamos ISPF).

De hecho, esto fue lo que le pasó hace unas semanas a un compañero. A pesar de tener más de 5 años de experiencia trabajando con Host, el problema es que llevaba otros 5 años sin tocar ISPF y, por tanto, cuando llegó aquí e intentó hacer una búsqueda múltiple, se quedó en blanco. Aunque parezca mentira, todo conocimiento se va desvaneciendo con el paso del tiempo si no se refresca a menudo.

Utilidad Data Set List Utility de ISPF


Cuando entramos en la ventana Data Set List Utility de ISPF (opción 3.4 para los amigos), normalmente lo hacemos con la idea de acceder a un determinado fichero (o librería) y ver su contenido. Por tanto, en estos casos ya nos sabemos el nombre de dicho dataset y lo único que tenemos que hacer es especificar su nombre en la utilidad.

Por ejemplo, si queremos buscar el fichero ASPR.V7R01.JJST.FUENTES.BACKUP, pondremos el nombre en el campo DSNAME LEVEL en la utilidad.


A continuación, pulsaremos INTRO y la herramienta nos mostrará el fichero (o librería) que coincida con dicha denominación.



Este es el funcionamiento estándar y no tiene mucha más historia. Una vez se nos haya mostrado el fichero encontrado, no deberíamos tener problemas en acceder a su contenido y ver los registros (o los objetos) que se encuentren en su interior.

Una vez examinada la búsqueda simple, el próximo día (en un nuevo post) procederemos a detallar en qué consiste la búsqueda múltiple de ficheros. Además, mostraremos ejemplos de los casos más comunes a los que podremos recurrir para agilizar nuestras ediciones desde la herramienta ISPF.

Y eso es todo por ahora. Por tanto, quedáis invitados a la segunda parte del post, donde completaremos la revisión iniciada hoy. Una vez visto el artículo completo, ya no deberíais tener problema alguno para buscar varios ficheros a la vez desde ISPF.

Saludos.
Related Posts Plugin for WordPress, Blogger...