MEMOEDIT()
Edita o visualiza campos memo o cadenas de carácteres
------------------------------------------------------------------------------
Sintaxis
MEMOEDIT([<cCadena>],
[<nSuperior>], [<nIzquierda>],
[<nInferior>], [<nDerecha>],
[<lModoEdici.n>],
[<cfunciónUsuario>],
[<nLongitudL.nea>],
[<nTama.oTabulador>],
[<nFilaMemoInterTexto>],
[<nColumnaMemoInterTexto>],
[<nFilaVentana>],
[<nColumnaVentana>]) --> cMemoInterTexto
Argumentos
<cCadena> es el campo memo o la cadena de carácteres que se va a
copiar en la memoria intermedia de MEMOEDIT(). Si no se especifica, la
memoria intermedia de texto est. vac.a.
<nSuperior>, <nIzquierda>, <nInferior> y <nDerecha> son
las coordenadas superior izquierda e inferior derecha, respectivamente,
de la ventana. Los valores de fila especificados pueden estar
comprendidos entre cero y MAXROW() y los de columna entre entre cero y
MAXCOL(). Si no se especifican, las coordenadas por defecto son 0, 0,
MAXROW() y MAXCOL().
<lModoEdici.n> determina si la memoria intermedia de texto puede
editarse o sólo mostrarse en pantalla. Si se especifica verdadero (.T.),
el usuario puede modificar la memoria intermedia. Si se especifica falso
(.F.), sólo puede visualizarla. El valor por defecto es verdadero (.T.).
<cfunciónUsuario> es el nombre de la función que se ejecuta cuando
se pulsa una tecla no reconocida por MEMOEDIT() y cuando no quedan
teclas pendientes en la memoria intermedia del teclado.
<cfunciónUsuario> se especifica como valor de carácteres, sin paréntesis
ni argumentos. Si se especifica falso (.F.) en este argumento, se
muestra en pantalla <cCadena> y se termina inmediatamente MEMOEDIT().
Este argumento modifica el comportamiento autom.tico de MEMOEDIT().
Consulte la Descripción que se da a continúa.ión.
<nLongitudL.nea> determina la longitud de las líneas mostradas en la
ventana de MEMOEDIT(). Si una línea es mayor que <nLongitudL.nea>, el
texto salta autom.ticamente a la línea siguiente de la ventana. Si
<nLongitudL.nea> es mayor que el número de columnas de la ventana, .sta
se desplaza al llegar el cursor al borde. Si no se especifica
<nLongitudL.nea>, la longitud de línea por defecto ser. (<nDerecha> -
<nIzquierda>).
<nTama.oTabulador> determina tama.o del carácter de tabulaci.n que
se inserta cuando se pulsa la tecla Tab. Si no se especifica, se
insertan cuatro espacios en vez de un carácter de tabulaci.n.
<nFilaMemoInterTexto> y <nColumnaMemoInter Texto> definen la
posición de visualización del cursor en la memoria intermedia de texto.
<nFilaMemoInterTexto> se numera a partir de uno y
<nColumnaMemoInterTexto> a partir de cero. Si no se especifican estos
argumentos, el cursor se coloca en la fila uno y columna cero de la
ventana MEMOEDIT().
<nFilaVentana> y <nColumnaVentana> definen la posición inicial
del cursor en la ventana MEMOEDIT(). Las filas y columnas se numeran a
partir de cero. Si no se especifican estos argumentos, la posición
inicial en la ventana es la fila cero y la posición de columna actual
del cursor.
Devuelve
MEMOEDIT() devuelve la memoria intermedia modificada si el usuario
finaliza la edici.n con Ctrl-W o una copia de <cCadena> si finaliza con
Esc.
Descripción
MEMOEDIT() es una función de interfaz de usuario y de edici.n de texto,
que permite editar campos memo y cadenas de carácteres largas. La
edici.n se lleva a cabo en el .rea especificada, que puede estar situada
en cualquier parte de la pantalla. Al igual que las restántes funciónes
de usuario, (ACHOICE() y DBEDIT()), MEMOEDIT() dispone de una serie de
modos e incluye una función de usuario que permite reconfiguración de
las teclas y otras actividades relacionadas con la programaci.n de la
tarea actual de edici.n.
. Memoria intermedia de texto: Cuando se utiliza MEMOEDIT()
especificando <cCadena>, .sta se copia en la memoria intermedia de
texto. El usuario edita realmente la memoria intermedia. Si no se
especifica <cCadena>, se muestra al usuario una memoria intermedia
vac.a para su edici.n.
Cuando el usuario sale de MEMOEDIT() pulsando Ctrl-W, se devuelve el
contenido modificado de la memoria intermedia. Si sale pulsando Esc,
se descarta la memoria intermedia y se devuelve una copia de la
<cCadena> original. En cualquier caso, el valor de retorno puede
asignarse m.s tarde a un campo memo o variable, o pasarse como
argumento a otra función.
. Modos de edici.n: MEMOEDIT() utiliza dos modos de edici.n,
que se controlan mediante el valor de <lModoEdici.n>. Si
<lModoEdici.n> es verdadero (.T.), MEMOEDIT() pasa al modo de edici.n
y el usuario puede modificar la memoria intermedia de MEMOEDIT(). Si
<lModoEdici.n> es falso (.F.), MEMOEDIT() pasa al modo de
visualización y el usuario sólo puede desplazarse por la memoria
intermedia, sin editarla ni poder insertar nuevo texto. Para
facilitar la visualización, se ha modificado el desplazamiento de
pantalla para que las flechas Arriba y Abajo suban o bajen el texto
de la memoria intermedia una línea dentro de la ventana de
MEMOEDIT().
. Introducci.n y edici.n de texto: Con la función
MEMOEDIT(), es posible introducir y editar texto situando el cursor y
a.adiendo o borrando carácteres. Para facilitar la edici.n del texto,
se han modificado algunas teclas de desplazamiento y de edici.n:
Teclas de Desplazamiento y Edici.n de MEMOEDIT()
---------------------------------------------------------------------
Tecla Acción
---------------------------------------------------------------------
Arriba/Ctrl-E Sube una línea
Abajo/Ctrl-X Baja una línea
Izquierda/Ctrl-S Pasa un carácter a la izquierda
Derecha/Ctrl-D Pasa un carácter a la derecha
Ctrl-Izquierda/Ctrl-A Pasa una palabra a la izquierda
Ctrl-Derecha/Ctrl-F Pasa una palabra a la derecha
Inicio Pasa al principio de la línea actual
Fin Pasa al final de la línea actual
Ctrl-Inicio Pasa al principio de la ventana actual
Ctrl-Fin Pasa al final de la ventana actual
ReP.g Pasa a la ventana de edici.n anterior
AvP.g Pasa a la siguiente ventana de edici.n
Ctrl-ReP.g Pasa al principio del texto memo
Ctrl-AvP.g Pasa al final del texto memo
Intro Pasa al principio de la línea siguiente
Suprimir Borra el carácter de la posición del cursor
Retroceso Borra el carácter situado a la izquierda
del cursor
Tabulador Inserta un carácter de tabulador o espacios
Car.cter imprimible Inserta ese carácter
Ctrl-Y Borra la línea actual
Ctrl-T Borra la palabra a la derecha
Ctrl-B Da formato a un p.rrafo
Ctrl-V/Ins Activa/desactiva el modo de inserci.n
Ctrl-W Finaliza la edici.n guardando los cambios
Esc Anula edici.n y devuelve la cadena original
---------------------------------------------------------------------
Para la introducci.n de texto existen dos modos: inserci.n y
sobreescritura. Al invocar MEMOEDIT(), el modo por defecto es
sobreescritura. Para cambiar el modo de edici.n puede pulsarse la
tecla Ins, que intercambia los modos de inserci.n y sobreescritura.
También puede cambiarse en una función utilizando READINSERT() o
devolviendo 22. En el modo de inserci.n, los carácteres se introducen
en la posición actual del cursor en la memoria intermedia,
desplaz.ndose el resto del texto a la derecha. El modo de inserci.n
se indica en el .rea de la línea de estado. En el modo de
sobreescritura, los carácteres se introducen en la posición actual
del cursor sobreescribiendo los carácteres existentes, sin
desplazarse el resto de la memoria intermedia.
Seg.n se introduce texto y el cursor llega al borde de la ventana
MEMOEDIT(), la línea actual salta a la línea siguiente de la memoria
intermedia y se inserta un retorno de carro autom.tico (CHR(141)). Si
se especifica un argumento <nLongitudL.nea>, el texto salta cuando la
posición del cursor coincide con <nLongitudL.nea>. Si
<nLongitudL.nea> es mayor que la anchura de MEMOEDIT(), la ventana se
desplaza al llegar el cursor al borde. Para iniciar explícitamente
una nueva línea o p.rrafo, el usuario debe pulsar Intro.
. Pantalla de edici.n: Cuando aparece en pantalla
MEMOEDIT(), sobreescribe el .rea de la pantalla especificada sin
guardar la pantalla subyacente. Tampoco muestra un borde o t.tulo.
Para realizar estas acciones, debe crear un procedimiento o función
que realice estas acciones y, luego, invoque MEMOEDIT(). Consulte el
siguiente ejemplo.
. función de usuario: <cfunciónUsuario>, especificada como
argumento, maneja las excepciones del teclado y reconfigura las
teclas especiales. MEMOEDIT() invoca en distintas ocasiones a la
función de usuario, normalmente como respuesta a teclas no
reconocidas. Las teclas que producen excepciones del teclado son
todas las teclas de control, teclas de función y teclas Alt. Como
MEMOEDIT() no procesa estas teclas, es posible reconfigurarlas.
Algunas de ellas tienen asignada una acci.n por defecto. Con la
función de usuario pueden realizarse distintas acciones, dependiendo
del modo actual de MEMOEDIT() y del valor de retorno que indica a
MEMOEDIT() qu. debe hacer a continúa.ión.
Cuando se especifica como argumento la función de usuario, MEMOEDIT()
define dos clases de teclas: no configurables y excepciones del
teclado. Cuando se pulsa una tecla no configurable, MEMOEDIT() la
ejecuta o, en caso contrario, genera una excepci.n del teclado e
invoca a la función de usuario. Cuando en la memoria intermedia del
teclado no quedan teclas para ser procesadas por MEMOEDIT(), se
invoca de nuevo a la función de usuario.
Cuando MEMOEDIT() llama a la función de usuario, le pasa
autom.ticamente tres parámetros: el modo de MEMOEDIT(), la línea
actual de la memoria intermedia y la columna actual de la memoria
intermedia. El modo indica el estado actual de MEMOEDIT(), que
depende de la .ltima tecla pulsada o de la .ltima acci.n realizada
antes de ejecutar la función de usuario. A continúa.ión se indican
los modos posibles:
Modos de MEMOEDIT()
---------------------------------------------------------------------
Modo Memoedit.ch Descripción
---------------------------------------------------------------------
0 ME_IDLE Inactividad, se han procesado todas las teclas
1 ME_UNKEY Tecla desconocida, el texto memo no se ha
modificado
2 ME_UNKEYX Tecla desconocida, el texto memo se ha
modificado
3 ME_INIT Modo de inicializaci.n
---------------------------------------------------------------------
Un modo de 3 indica que MEMOEDIT() est. en modo de inicializaci.n. Al
especificar <cfunciónUsuario>, MEMOEDIT() realiza una llamada a la
función de usuario inmediatamente después de haberse invocado. En ese
momento, el usuario debe devolver una petición para seleccionar los
distintos modos de formato de texto de MEMOEDIT(): salto autom.tico
de línea, desplazamiento de pantalla o inserci.n. MEMOEDIT() llama a
la función varias veces, permaneciendo en el modo de inicializaci.n
hasta que el usuario devuelva 0. Entonces la memoria intermedia se
muestra en pantalla y el usuario pasa al modo de edici.n seleccionado
con <lModoEdici.n>. Recuerde que, si el salto autom.ticop de línea
est. activado cuando MEMOEDIT() pasa del modo de inicializaci.n al de
edici.n, toda la memoria intermedia se formatea con <nLongitudL.nea>.
Para evitar esta acci.n de formato inicial, desactive el salto
autom.tico de línea durante la inicializaci.n. Recuerde también que
la activaci.n/desactivaci.n del desplazamiento y el salto autom.tico
de línea no están asignados inicialmente a ningúna tecla, pero pueden
asignarse a una mediante la función de usuario.
Los modos 1 y 2 indican que MEMOEDIT() ha recibido una tecla
irreconocible o una tecla configurable. Las teclas configurables se
procesan devolviendo 0 para ejecutar la acci.n por defecto de
MEMOEDIT(). Si se devuelve otro valor se realiza otra acci.n,
redefiniendo as. la tecla. Si es una tecla irreconocible, puede
asign.rsele una acci.n que devuelva un valor que solicite una acci.n
del teclado o que realice una acci.n predefinida.
El modo 0 indica que MEMOEDIT() est. inactivo en ese momento porque
no quedan teclas para procesar. Cuando MEMOEDIT() est. inactivo, se
invoca la función de usuario. En ese momento, normalmente se
actualizan las visualizaciónes del número de línea y de columna.
Los otros dos parámetros, línea y columna actuales, indican la
posición actual del cursor en la memoria intermedia al invocar la
función de usuario. Las líneas se empiezan a contar en la posición
uno y los de columna en la posición cero.
En los modos 1, 2 . 3, el usuario puede devolver un valor que indique
a MEMOEDIT() la siguiente acci.n que debe realizar. La tabla
siguiente muestra los posibles valores devueltos y sus consecuencias:
Valores de Retorno a la función de Usuario de MEMOEDIT()
---------------------------------------------------------------------
Valor Memoedit.ch Acción
---------------------------------------------------------------------
0 ME_DEFAULT Realiza la acci.n por defecto
1-31 ME_UNKEY Procesa la acci.n solicitada que corresponde
al valor de la tecla
32 ME_IGNORE Ignora las teclas desconocidas
33 ME_DATA Trata las teclas desconocidas como datos
34 ME_TOGGLEWRAP Activa/desactiva el modo de salto autom.tico
de línea
35 ME_TOGGLESCROLL Activa/desactiva el modo de desplazamiento
de pantalla
100 ME_WORDRIGHT Se desplaza una palabra a la derecha
101 ME_BOTTOMRIGHT Se desplaza al final del texto
---------------------------------------------------------------------
. Ficheros de cabecera: Para facilitar la memorizaci.n y
utilización de los valores de modo y de petición, existe en
\CLIPPER5\INCLUDE un fichero de cabecera llamado Memoedit.ch. En el
mismo directorio existe Inkey.ch, que contiene constantes declaradas
para todos los valores de INKEY().
Notas
. configuración de teclas: Si se especifica una
<cfunciónUsuario>, pueden configurarse las teclas que se incluyen en
la siguiente tabla.
Teclas Configurables de MEMOEDIT()
---------------------------------------------------------------------
Tecla Acción por Defecto
---------------------------------------------------------------------
Ctrl-Y Borra la línea actual
Ctrl-T Borra la palabra a la derecha
Ctrl-B Da formato al p.rrafo
Ctrl-V/Ins Activa/desactiva el modo de inserci.n
Ctrl-W Finaliza la edici.n guardando los cambios
Esc Anula la edici.n devolviendo la cadena original
---------------------------------------------------------------------
Si la tecla es configurable, se devuelve 0 para ejecutar la acci.n
por defecto de MEMOEDIT(). Si se devuelve otro valor, no obstante, se
ejecuta otra acci.n del teclado lo que redefine la tecla. Si no se
trata una tecla configurable reconocida por MEMOEDIT(), también puede
asign.rsele una acci.n devolviendo un valor que solicite una de las
acciones incluidas en la tabla anterior.
. Salto autom.tico de línea: El salto autom.tico de línea es
un modo de formato que puede activarse y desactivarse devolviendo 34
desde la función de usuario. Si est. activado (opción por defecto),
MEMOEDIT() inserta un retorno de carro/salto de línea autom.tico en
la interrupci.n de texto m.s cercana al borde de la ventana o al
terminar la línea (lo que ocurra primero). Si est. desactivado,
MEMOEDIT() desplaza la memoria intermedia m.s all. del borde de la
ventana, hasta que el cursor llegue al fin de línea. En ese punto, el
usuario debe pulsar Intro (insertando un retorno de carro/salto de
línea forzado) para pasar a la línea siguiente.
. Formato de p.rrafos: Al pulsar Ctrl-B, o devolver 2 desde
una función de usuario, se vuelve a formatear la memoria intermedia
hasta encontrar un retorno de carro forzado (fin de p.rrafo) o el
final de la memoria intermedia, independientemente de que el salto
autom.tico de línea est. activado o no.
. Retornos de carro autom.ticos: En CA-Clipper, la
inserci.n de carácteres de retorno de carro/salto de línea autom.tico
nunca se permite que cambie el contenido significativo del texto. Es
decir, cuando se inserta un retorno de carro/salto de línea
autom.tico entre dos palabras, se mantienen los carácteres de espacio
que hay entre las dos palabras. Al cambiar el formato del texto, se
eliminan todos los carácteres de retorno de carro/salto de línea
autom.tico. Esto deja el texto en su formato original y trata
adecuadamente los casos en los que se ha insertado un retorno de
carro/salto de línea autom.tico en mitad de una palabra.
En la versi.n Summer '87 de MEMOEDIT(), al insertar un retorno de
carro/salto de línea autom.tico, se suprime un carácter de espacio en
ese punto del texto. Si posteriormente se formatea el texto
utilizando una anchura de línea diferente, todos los retornos de
carro/saltos de línea autom.ticos se sustituyen por un espacio. Sin
embargo, si la cadena de texto se formatea mediante alguna de las
funciónes de tratamiento de texto de CA-Clipper, las palabras que
estaban separadas por un retorno de carro/salto de línea autom.tico
se ejecutan juntas, porque este carácter no se sustituye por un
espacio.
Para evitarlo, los textos formateados con la versi.n Summer '87 de
MEMOEDIT() deben procesarse para sustituir los carácteres de retorno
de carro /salto de línea autom.tico por espacios. Esto puede
realizarse mediante la función STRTRAN(), tal como se indica a
continúa.ión.
STRTRAN( <texto>, CHR(141)+CHR(10), " " )
Para convertir los valores memo de una base de datos existente, puede
utilizarse el siguiente programa de dos líneas:
USE <xcBasedeDatos>
REPLACE ALL <idMemo> WITH ;
STRTRAN( <idMemo>, CHR(141)+CHR(10), " " )
Debido al formato del fichero (.dbt), la sustituci.n de todos los
sucesos de un campo memo puede hacer que el fichero (.dbt) aumente
notablemente. El fichero (.dbt) puede reducirse copiando el fichero
(.dbf) en un nuevo fichero.
En ficheros (.dbt) muy grandes, el procedimiento anterior puede no
ser factible. En tal caso, puede utilizarse el programa DBT50.EXE,
situado en el directorio \CLIPPER5\BIN. DBT50 examina un fichero
(.dbt) completo, sustituyendo todos los pares de retorno de
carro/salto de línea autom.tico por dos espacios. Aunque esto produce
el efecto no deseado de separar determinadas palabras con dos
espacios en vez de uno, permite procesar el fichero directamente sin
necesidad de utilizar espacio de disco adicional. DBT50 modifica
.nicamente los carácteres de retorno de carro/salto de línea
autom.tico del fichero objeto. El resto del texto no se modifica.
. Edici.n de ficheros de texto: MEMOEDIT() edita ficheros de
texto si pueden leerse en una variable de carácteres de CA-Clipper.
Esto puede hacerse mediante la función MEMOREAD(). Despu.s de editar
el contenido del fichero de texto incluido en la variable de
carácteres, debe volver a escribirse mediante MEMOWRIT().
Ejemplos
. Este ejemplo permite examinar un campo memo, pero impide
realizar cambios en la memoria intermedia:
USE Cliente NEW
SET CURSOR OFF
MEMOEDIT(NotasCli, 5, 10, 20, 69, .F.)
SET CURSOR ON
. El siguiente ejemplo permite editar un campo memo, volviendo a
asignar los cambios al mismo:
USE Cliente NEW
REPLACE NotasCli WITH ;
MEMOEDIT(NotasCli, 5, 10, 20, 69)
. Este ejemplo crea una cadena de carácteres mediante
MEMOEDIT():
LOCAL cNotas
cNotas = MEMOEDIT()
. El ejemplo siguiente es una función que edita una cadena de
carácteres en una ventana emmarcada, con un t.tulo:
FUNCTION EditMemo( cCadena, cTitulo,;
nSup, nIzda, nInf, nDer )
LOCAL cPantalla := SAVESCREEN(nSup nIzda,;
nInf, nDer)
@ nSup - 1, nIzda - 2 CLEAR TO nInf + 1,;
nDer + 2
@ nSup - 1, nIzda - 2 TO nInf + 1, nDer + 2
@ nSup - 1, nIzda SAY "[" + cTitulo + "]"
cCadena = MEMOEDIT(cCadena, nSup, nIzda,;
nInf, nDer)
RESTSCREEN(nSup, nIzda, nInf, nDer, cPantalla)
RETURN (cCadena)
. Este ejemplo lee el contenido de un fichero de texto incluido
en una variable de carácteres, lo edita y lo vuelve a escribir en el
disco:
LOCAL cCadena := MEMOREAD("Text.txt")
cCadena := MEMOEDIT(cCadena)
IF !MEMOWRIT("Text.txt", cCadena)
? "Error escritura"
BREAK
ENDIF
RETURN
. Este ejemplo contiene una función que muestra en pantalla un
mensaje que describe el modo actual de MEMOEDIT(). Además, en el modo
ME_UNKEY, la función realizar. una acci.n ME_WORDRIGHT o
ME_BOTTOMRIGHT, dependiendo de la tecla de función asociada que se
haya pulsado:
#include "memoedit.ch"
#include "inkey.ch"
PROCEDURE Main()
USE Cliente NEW
REPLACE NotasCli WITH;
MEMOEDIT( NotasCli, 5, 5, 15, 75, .T., "MemoUDF" )
RETURN
FUNCTION MemoUDF( nModo, nLinea, nCol )
LOCAL nTecla := LASTKEY()
LOCAL nValDev := ME_DEFAULT // Acción devuelta por
// defecto
DO CASE
CASE nModo == ME_IDLE
@ 20, 5 SAY "El modo es ME_IDLE "
CASE nModo == ME_UNKEY
@ 20, 5 SAY "El modo es ME_UNKEY "
DO CASE
CASE nTecla == K_F2
nValDev := ME_WORDRIGHT
CASE nTecla == K_F3
nValDev := ME_BOTTOMRIGHT
ENDCASE
CASE nModo == ME_UNKEYX
@ 20, 5 SAY "El modo es ME_UNKEYX"
OTHERWISE
@ 20, 5 SAY "El modo es ME_INIT "
ENDCASE
RETURN nValDev
Ficheros: La biblioteca asociada es EXTEND.LIB,
los ficheros de cabecera son Memoedit.ch y Inkey.ch.
MEMOLINE()
Extrae una línea de texto de la cadena de carácteres o campo memo
------------------------------------------------------------------------------
Sintaxis
MEMOLINE(<cCadena>,
[<nLongitudL.nea>],
[<nNúmeroL.nea>],
[<nTama.oTabulador>],
[<lSaltoL.nea>]) --> cL.nea
Argumentos
<cCadena> es el campo memo o cadena de carácteres del que se va a
extraer una línea de texto.
<nLongitudL.nea> especifica el número de carácteres de línea y puede
estar comprendido entre 4 y 254. Si no se especifica, la longitud de
línea por defecto es 79.
<nNúmeroL.nea> es el número de línea que se va a extraer. Si no se
especifica, el valor por defecto es uno.
<nTama.oTabulador> define el tama.o del tabulador. Si no se
especifica, el valor por defecto es de cuatro espacios. Si
<nTama.oTabulador> es mayor o igual que <nLongitudL.nea>, el tama.o de
tabulador se convierte autom.ticamente en <nLongitudL.nea> - 1.
<lSaltoL.nea> activa/desactiva el salto autom.tico de línea. Si se
especifica verdadero (.T.) se activa el salto de línea y si de
especifica falso (.F.) se desactiva. El valor por defecto es verdadero
(.T.).
Devuelve
MEMOLINE() devuelve la línea de texto especificada por <nNúmeroL.nea> en
<cCadena>, como cadena de carácteres. Si la línea tiene menos carácteres
que la longitud indicada, el valor de retorno se rellena con espacios en
blanco. Si el número de línea es mayor que el número total de líneas de
<cCadena>, MEMOLINE() devuelve una cadena nula ("").
Si <lSaltoL.nea> es verdadero (.T.) y la longitud de línea indicada
interrumpe la línea en mitad de una palabra, dicha palabra no se incluye
en el valor de retorno, sino que se muestra al principio de la siguiente
línea extra.da mediante MEMOLINE().
Si <lSaltoL.nea> es falso (.F.), MEMOLINE() devuelve solamente el número
de carácteres especificado por la longitud de línea. La siguiente línea
extra.da por MEMOLINE() comienza en el carácter que va a continúa.ión
del siguiente retorno de carro forzado, y los carácteres intermedios no
se procesan.
Descripción
MEMOLINE() es una función que se utiliza con MLCOUNT() para extraer
líneas de texto de cadenas de carácteres y campos memo, bas.ndose en el
número de carácteres por línea. Es la función m.s sencilla de CA-Clipper
para mostrar en pantalla campos memo y cadenas largas.
La forma de utilización m.s f.cil consiste en determinar el número de
líneas del campo memo o cadena de carácteres útilizando MLCOUNT() con el
mismo número de carácteres por línea, tama.o de tabulador y selecci.n de
salto de línea que va a utilizar con MEMOLINE(). Este valor puede
utilizarse como l.mite superior de FOR...NEXT para extraer las líneas
del campo memo o cadena de carácteres mediante MEMOLINE() y procesarlas
con cualquier combinación de funciónes y mandatos de salida necesarios.
Ejemplos
. Este ejemplo muestra el m.todo general para mostrar en
pantalla campos memo y cadenas de carácteres largas utilizando una
combinación de las funciónes MLCOUNT() y MEMOLINE():
LOCAL nLongitudLinea := 40, nTamanoTabulador := 3,;
lSaltoLinea := .T.
LOCAL nLineas, nLineaActual
USE Cliente INDEX NombreCli NEW
//
nLineas := MLCOUNT(NotasCli, nLongitudLinea,;
nTamanoTabulador, lSaltoLinea)
//
SET PRINTER ON
FOR nLineaActual := 1 TO nLineas
? MEMOLINE(NotasCli, nLongitudLinea, nLineaActual;
nTamanoTabulador, lSaltoLinea)
NEXT
SET PRINTER OFF
Ficheros: La biblioteca asociada es EXTEND.LIB.
MEMOREAD()
Devuelve el contenido de un fichero de disco en forma de cadena de carácteres
------------------------------------------------------------------------------
Sintaxis
MEMOREAD(<cFichero>) --> cCadena
Argumentos
<cFichero> es el nombre del fichero que se va a leer en el disco.
Debe incluir una extensión, si la hay, y una vía de acceso opciónal.
Devuelve
MEMOREAD() devuelve el contenido de un fichero de texto en forma de
cadena de carácteres. El máximo tama.o de fichero que puede leerse es de
65.535 carácteres (64K), que es el tama.o máximo de una cadena. Si no se
encuentra <cFichero>, MEMOREAD() devuelve una cadena nula ("").
Descripción
MEMOREAD() es una función que lee en la memoria un fichero de disco,
donde se maneja como cadena de carácteres o se asigna a un campo memo.
MEMOREAD() se utiliza con MEMOEDIT() y MEMOWRIT() para editar un fichero
de disco importado y volver a escribirlo después en el disco. MEMOREAD()
busca <cFichero> comenzando en el directorio del DOS actual. Si el
fichero no se encuentra, MEMOREAD() busca en la vía del DOS. MEMOREAD()
no utiliza los valores DEFAULT o PATH de CA-Clipper para la b.squeda de
<cFichero>.
En un entorno de red, MEMOREAD() intenta abrir el fichero especificado
en modo compartido y de sólo lectura. Si ya ha sido abierto en modo
exclusivo por de otro proceso, MEMOREAD() devuelve una cadena nula ("").
Ejemplos
. Este ejemplo utiliza MEMOREAD() para asignar el contenido de
un fichero de texto al campo memo Notas y a una variable de tipo
carácter:
REPLACE Notas WITH MEMOREAD("Temp.txt")
cCadena = MEMOREAD("Temp.txt")
. Este ejemplo define una función que edita un fichero de disco:
FUNCTION Editor( cFichero )
LOCAL cCadena
IF (cCadena := MEMOREAD(cFichero)) == ""
? "Error de lectura de " + cFichero
RETURN .F.
ELSE
MEMOWRIT(cFichero, MEMOEDIT(cCadena))
RETURN .T.
ENDIF
Ficheros: La biblioteca asociada es EXTEND.LIB.
MEMORY()
Determina la cantidad de memoria libre disponible
------------------------------------------------------------------------------
Sintaxis
MEMORY(<nExp>) --> nKbytes
Argumentos
<nExp> es un valor numérico que determina el significado del valor
que devuelve MEMORY(), como se indica a continúa.ión:
Valores del Argumento de MEMORY()
------------------------------------------------------------------------
Valor Significado
------------------------------------------------------------------------
0 Espacio total estimado disponible para valores de tipo carácter
1 Bloque contiguo m.s grande disponible para valores de tipo
carácter
2 Area disponible para mandatos RUN
------------------------------------------------------------------------
Devuelve
MEMORY() devuelve un valor numérico entero que representa la cantidad de
memoria disponible, en incrementos de un kilobyte.
Descripción
MEMORY() es una función de entorno que informa de los distintos estados
del .rea de memoria disponible. (Esta zona es el .rea din.mica de la
memoria que almacena cadenas de carácteres y ejecuta mandatos RUN.)
Ejemplos
. Este ejemplo utiliza MEMORY() antes de un mandato RUN para
determinar si se dispone de suficiente memoria para ejecutar el
programa externo:
#define MEM_CHAR 0
#define MEM_BLOCK 1
#define MEM_RUN 2
//
IF MEMORY(MEM_RUN) >= 128
RUN MYPROG
ELSE
? "Memoria insuficiente para ejecutar el programa"
BREAK
ENDIF
Ficheros: La biblioteca asociada es CLIPPER.LIB.
MEMOTRAN()
Sustituye los retornos de carro/saltos de línea contenidos en una cadena de
carácteres
------------------------------------------------------------------------------
Sintaxis
MEMOTRAN(<cCadena>,
[<cSustRCForzado>],
[<cSustRCAutom.tico>]) --> cNuevaCadena
Argumentos
<cCadena> es la cadena de carácteres o campo memo que se va a leer.
<cSustRCForzado> es el carácter por el que se va a sustituir cada
retorno de carro/salto de línea forzado. Si no se especifica, el valor
por defecto es un punto y coma (;).
<cSustRCAutom.tico> es el carácter por el que se va a sustituir cada
retorno de carro/salto de línea autom.tico. Si no se especifica, el
valor por defecto es un espacio.
Devuelve
MEMOTRAN() devuelve una copia de <cCadena> en la que se han sustituido
los retornos de carro/saltos de línea especificados.
Descripción
MEMOTRAN() es una función que convierte un campo memo o una cadena de
carácteres larga, que contiene retornos de carro/saltos de línea
autom.ticos y forzados, en un formato que pueda mostrarse en pantalla.
Esta combinación de dos carácteres es un indicador de fin de línea
colocado en una cadena por MEMOEDIT(). Se insertan retornos de carro
autom.ticos (CHR(141)) cuando una línea que es m.s larga que la anchura
de la ventana de MEMOEDIT() salta a la línea siguiente. Se insertan
retornos de carro forzados (CHR(13)) cuando el usuario pulsa
explícitamente la tecla Intro.
MEMOTRAN() sirve para visualizar un campo memo de un REPORT FORM sin
saltos de línea autom.ticos al encontrar retornos de carro autom.ticos.
MEMOTRAN() lo soluciona convirtiendo los retornos de carro autom.ticos
en espacios. Recuerde, no obstante, que es necesario declarar MEMOTRAN()
como función externa mediante la sentencia REQUEST, si se utiliza en un
REPORT FORM y no se especifica en ningúna otra parte del programa
actual.
Ejemplos
. El siguiente ejemplo suprime todos los carácteres de fin de
línea de un campo memo:
REPLACE Notas WITH MEMOTRAN(Notas)
Ficheros: La biblioteca asociada es EXTEND.LIB.
MEMOWRIT()
Escribe una cadena de carácteres o un campo memo en un fichero de disco
------------------------------------------------------------------------------
Sintaxis
MEMOWRIT(<cFichero>, <cCadena>) --> lExito
Argumentos
<cFichero> es el nombre del fichero de disco de destáno, incluyendo
la extensión y el indicador de vía y unidad opciónales.
<cCadena> es la cadena de carácteres o campo memo que se va a
escribir en <cFichero>.
Devuelve
MEMOWRIT() devuelve verdadero (.T.) si la operación.de escritura se ha
realizado con .xito; en caso contrario, devuelve falso (.F.).
Descripción
MEMOWRIT() es una función que escribe una cadena de carácteres o campo
memo en un fichero de disco. Si no se especifica la vía, MEMOWRIT()
escribe <cFichero> en el directorio actual del DOS, en vez de en el
directorio especificado por el valor de SET DEFAULT actual. Si
<cFichero> ya existe, se sobreescribe.
MEMOWRIT() se utiliza generalmente con MEMOREAD() para cargar en memoria
ficheros de texto, donde pueden editarse, mostrarse en pantalla y volver
a escribirse en el disco. Asimismo, MEMOWRIT() puede utilizarse como un
m.todo r.pido de exportar un campo memo a un fichero de texto.
Ejemplos
. Este ejemplo utiliza MEMOWRIT() con MEMOREAD() para permitir
la edici.n de campos memo con un editor externo:
LOCAL cEditor := "MYEDIT.EXE"
USE Ventas NEW
IF MEMOWRIT("Cliptmp.txt", Notas)
RUN (cEditor + " Cliptmp.txt")
REPLACE Notas WITH MEMOREAD("Cliptmp.txt")
ELSE
? "Error al escribir Cliptmp.txt"
BREAK
ENDIF
Ficheros: La biblioteca asociada es EXTEND.LIB.
MEMVARBLOCK()
Devuelve un bloque de código de asignación/lectura para una variable de
memoria dada
------------------------------------------------------------------------------
Sintaxis
MEMVARBLOCK(<cNombreVarmem>) --> bBloqueVarmem
Argumentos
<cNombreVarmem> es el nombre de la variable a la que hace referencia
el bloque de lectura/escritura, especificada como cadena de carácteres.
Devuelve
MEMVARBLOCK() devuelve un bloque de código que, al evaluarse, permite
asignar u obtener el valor de la variable de memoria especificada. Si no
existe la variable, MEMVARBLOCK() devuelve NIL.
Descripción
El bloque de código creado por MEMVARBLOCK() realiza dos operación.s,
dependiendo de si se pasa un argumento al bloque de código cuando se
eval.a. Si se eval.a con un argumento, asigna ese valor a
<cNombreVarmem>. Si se eval.a sin argumento, recupera el valor de
<cNombreVarmem>.
Notas
. MEMVARBLOCK() sólo permite crear bloques de asignación/lectura
de variables de nombres conocidos durante la ejecución.
MEMVARBLOCK(), por tanto, no puede utilizarse para crear bloques de
asignación/lectura de variablesólocales o estáticas. La misma
restricci.n se aplica a la creaci.n de bloques mediante el operador
de macro (&).
Ejemplos
. Este ejemplo compara MEMVARBLOCK() con un bloque de código
creado con el operador de macro (&). Observe que la utilización de
MEMVARBLOCK() le permite evitar la velocidad y el tama.o iniciales
del operador de macro:
PRIVATE var := "Esto es una cadena"
//
// Bloque de asignación/lectura definido mediante
// el operador de macro
bLeerEscr := &( "{ |valEst|;
IF( valEst == NIL, var, var := valEst ) }" )
// Bloque de asignación/lectura definido mediante
//MEMVARBLOCK()
// el bLeerEscr creado aqu. es el equivalente
// funciónal del bLeerEscr anterior
bEstObt := MEMVARBLOCK("var")
Ficheros: La biblioteca asociada es CLIPPER.LIB.
MIN()
Devuelve el menor de dos valores numéricos o de fecha
------------------------------------------------------------------------------
Sintaxis
MIN(<nExp1>, <nExp2>) --> nMenor
MIN(<fExp1>, <fExp2>) --> fMenor
Argumentos
<nExp1> y <nExp2> son los valores numéricos que se van a
comparar.
<fExp1> y <fExp2> son los valores de fecha que se van a
comparar.
Devuelve
MIN() devuelve el menor de dos argumentos. El valor de retorno es del
mismo tipo de datos que los argumentos.
Descripción
MIN() es una función numérica y de fecha que asegura que el valor de una
expresión sea inferior a un mínimo especificado. La función inversa de
MIN() es MAX(), que devuelve el mayor de dos valores numéricos o de
fecha.
Ejemplos
. En los siguientes ejemplos, MIN() devuelve el menor de dos
valores numéricos:
? MIN(99, 100) // Resultado: 99
? MIN(100, 99) // Resultado: 99
. En los ejemplos siguientes, MIN() compara valores de fecha:
? DATE() // Resultado: 09/01/90
? MIN(DATE(), DATE() + 30) // Resultado: 09/01/90
Ficheros: La biblioteca asociada es CLIPPER.LIB.
MLCOUNT()
Cuenta el número de líneas de una cadena de carácteres o de un campo memo
------------------------------------------------------------------------------
Sintaxis
MLCOUNT(<cCadena>, [<nLongitudL.nea>],
[<nTama.oTabulador>], [<lSaltoL.nea>]) --> nL.neas
Argumentos
<cCadena> es la cadena de carácteres o el campo memo en el que se va
a realizar el recuento.
<nLongitudL.nea> especifica el número de carácteres por línea y
puede estar comprendido entre 4 y 254. Si no se especifica, la longitud
de línea por defecto es 79.
<nTama.oTabulador> define el tama.o de tabulador. Si no se
especifica, el valor por defecto es de cuatro espacios. Si
<nTama.oTabulador> es mayor o igual que <nLongitudL.nea>, el tama.o de
tabulador se convierte autom.ticamente en <nLongitudL.nea> - 1.
<lSaltoL.nea> activa o desactiva el salto autom.tico de línea. Si se
especifica verdadero (.T.) se activa el salto autom.tico de línea; si se
especifica falso (.F.) se desactiva. El valor por defecto es verdadero
(.T.).
Devuelve
MLCOUNT() devuelve el número de líneas de <cCadena>, dependiendo de la
<nLongitudL.nea>, el <nTama.oTabulador> y la activaci.n o desactivaci.n
del salto autom.tico de línea.
Descripción
MLCOUNT() es una función que se utiliza con MEMOLINE() para imprimir
cadenas de carácteres y campos memo, bas.ndose en el número de
carácteres por línea. En su forma m.s sencilla, MLCOUNT() devuelve el
número de líneas de la cadena de carácteres o del campo memo. Luego,
puede utilizar MEMOLINE() para extraer las líneas en el campo memo hasta
que no quede ningúna línea.
Si <lSaltoL.nea> es verdadero (.T.) y un fin de línea divide en dos una
palabra, el texto pasa a la línea sigiente incluyendo esa palabra. Si
<lSaltoL.nea> es falso (.F.), MLCOUNT() cuenta como línea actual el
número de carácteres especificado por <nLongitudL.nea>. La siguiente
línea comienza por el carácter que vaya detrás del siguiente retorno de
carro forzado o autom.tico que se encuentre y los restántes carácteres
se ignoran.
Ejemplos
. Este ejemplo muestra en pantalla el contenido de todos los
campos memo Notas del fichero de base de datos Ventas, una línea cada
vez:
USE Ventas NEW
nLongLinea = 65
//
DO WHILE !EOF()
nLineas = MLCOUNT(Ventas->Notas, nLongLinea)
FOR nLineaActual = 1 TO nLineas
? MEMOLINE(Ventas->Notas, nLongLinea, nLineaAct)
NEXT
SKIP
?
ENDDO
Ficheros: La biblioteca asociada es EXTEND.LIB.
MLCTOPOS()
Devuelve la posición absoluta del carácter en una cadena formateada en filas
y columnas
------------------------------------------------------------------------------
Sintaxis
MLCTOPOS(<cTexto>, <nAnchura>, <nL.nea>, <nCol>,
[<nTama.oTabulador>], [<lSaltoL.nea>]) -->nPosicion
Argumentos
<cTexto> es la cadena de texto que se va a tratar.
<nAnchura> es la anchura del formato de línea.
<nL.nea> es el número de línea, contando a partir de 1.
<nCol> es el número de columna, contando a partir de 0.
<nTama.oTabulador> es el número de columnas que hay entre las
posiciónes de tabulaci.n. Si no se especifica, el valor por defecto es
4.
<lSaltoL.nea> es el indicador de salto autom.tico de línea. Si no se
especifica, el valor por defecto es verdadero (.T.).
Devuelve
MLCTOPOS() devuelve la posición de byte dentro de <cTexto>, contando a
partir de 1.
Descripción
MLCTOPOS() es una función memo que determina la posición de byte que
corresponde a una línea y una columna determinadas dentro del texto
formateado. Recuerde que la numeraci.n de líneas comienza por uno,
mientras que la numeraci.n de columnas comienza por cero. Esta función
es compatible con MEMOEDIT(). El valor de retorno se cuenta a partir de
uno, lo que permite utilizarlo con SUBSTR() u otras funciónes de
cadenas.
MLCTOPOS() se utiliza con MPOSTOLC() para crear rutinas de b.squeda u
otros procesamientos de texto de MEMOEDIT(). Consulte el código fuente
del Editor de Programas, que se encuentra en el directorio
\CLIPPER5\SOURCE\PE.
Ejemplos
. Este ejemplo determina la posición de byte de la línea 5,
columna 3 de la cadena cTexto:
cTexto := "Recuerde en qu. lado del pan debe"+;
"ponerse la mantequilla."
//
? MLCTOPOS(cTexto, 5, 3, 0) // Resultado: 10
Ficheros: La biblioteca asociada es CLIPPER.LIB.
MLPOS()
Determina la posición de una línea en una cadena de carácteres o en un campo
memo
------------------------------------------------------------------------------
Sintaxis
MLPOS(<cCadena>, <nLongitudL.nea>, <nL.nea>, [<nTama.oTabulador>],
[<lSaltoL.nea>]) -->nPosici.n
Argumentos
<cCadena> es una cadena de carácteres o un campo memo.
<nLongitudL.nea> especifica el número de carácteres por línea.
<nL.nea> especifica el número de línea.
<nTama.oTabulador> define el tama.o del tabulador. El valor por
defecto es cuatro. Si <nTama.oTabulador> es mayor o igual que
<nLongitudL.nea>, el tama.o del tabulador se convierte en
<nLongitudL.nea> - 1.
<lSaltoL.nea> activa y desactiva el salto autom.tico de línea. Si se
especifica verdadero (.T.), se activa el salto de línea y si se
especifica falso (.F.), se desactiva. El valor por defecto es verdadero
(.T.).
Devuelve
MLPOS() devuelve la posición de carácter de <nL.nea> en <cCadena>, como
valor numérico entero. Si <nL.nea> es mayor que el número de líneas de
<cCadena>, MLPOS() devuelve la longitud de <cCadena>.
Ejemplos
. Este ejemplo utiliza MLPOS() para buscar la posición de una
línea determinada, suponiendo una longitud de línea dada:
cCadena = MEMOREAD("Temp.txt")
nLongLinea = 40
nLinea = 5
nPosicion = MLPOS(cCadena, nLongLinea, nLinea)
? SUBSTR(cCadena, nPosicion, 12)
Ficheros: La biblioteca asociada es EXTEND.LIB.
MOD()*
Devuelve el resto de dos números en formato dBASE III PLUS
------------------------------------------------------------------------------
Sintaxis
MOD(<nDividendo>, <nDivisor>) --> nResto
Argumentos
<nDividendo> es el dividendo de la operación.de divisi.n.
<nDivisor> es el divisor de la operación.de divisi.n.
Devuelve
MOD() devuelve un número que representa el resto de <nDividendo>
dividido por <nDivisor>.
Descripción
MOD() es una función numérica que emula la función MOD() de dBASE III
PLUS. Se ejecuta mediante el operador de resto de CA-Clipper (%).
Recuerde que existen diferencias entre la función MOD() de dBASE III+
y el operador de resto de CA-Clipper, que se describen en la siguiente
tabla:
Diferencias entre la función MOD() de dBASE III PLUS y el operador de
resto de CA-Clipper
------------------------------------------------------------------------
Dividendo Divisor Operador Resto MOD() función MOD() de dBASE
III PLUS
------------------------------------------------------------------------
3 0 Error Error 3
3 -2 1 -1 -1
-3 2 -1 1 1
-3 0 Error Error -3
-1 3 -1 2 2
-2 3 -2 1 1
2 -3 2 -1 -1
1 -3 1 -2 -2
------------------------------------------------------------------------
MOD() se incluye como función de compatibilidad y, por tanto, su
utilización no es recomendable. Puede sustituirse completamente por el
operador de resto (%).
Notas
. Divisores cero en dBASE III PLUS: En dBASE III PLUS, un
divisor cero devuelve el dividendo cualquiera que sea el valor del
mismo. En CA-Clipper, por el contrario, la divisi.n de cualquier
dividendo con un divisor cero provoca un error de ejecución.
. Divisores cero en versiones anteriores: En las versiones
de CA-Clipper anteriores a Summer '87, una divisi.n con un
divisor cero devolvía cero cualquiera que fuera el dividendo. En las
versiones Summer '87 y posteriores, devuelve un error de ejecución.
Ficheros: La biblioteca asociada es EXTEND.LIB,
el fichero fuente es SOURCE\SAMPLE\MOD.PRG.
MONTH()
Convierte un valor de fecha en un número de mes
------------------------------------------------------------------------------
Sintaxis
MONTH(<fFecha>) --> nMes
Argumentos
<fFecha> es el valor de fecha que se va a convertir.
Devuelve
MONTH() devuelve un valor numérico entero comprendido en el rango de 0 a
12. Si se especifica una fecha nula (CTOD("")) devuelve cero.
Descripción
MONTH() es una función de conversión de fechas que se utiliza cuando se
requiere un valor numérico de mes para calcular informes peri.dicos,
etc. MONTH() forma parte de un grupo de funciónes que devuelven los
componentes de un valor de fecha como valores numéricos. En este grupo
incluye DAY() y YEAR(), que devuelven respectivamente los valores de d.a
y a.o como valores numéricos. CMONTH() es una función relacionada, que
devuelve el nombre del mes a partir de un valor de fecha.
Ejemplos
. Los siguientes ejemplos devuelven el mes de la fecha del
sistema:
? DATE() // Resultado: 09/01/90
? MONTH(DATE()) // Resultado: 9
? MONTH(DATE()) + 1 // Resultado: 10
. Este ejemplo muestra a MONTH() realizando una acci.n con una
fecha nula:
#define NULL_DATE (CTOD(""))
? MONTH(NULL_DATE) // Resultado: 0
Ficheros: Fichero de biblioteca CLIPPER.LIB.
MPOSTOLC()
Devuelve la posición de línea y columna de una cadena formateada, bas.ndose
en una posición de byte especificada
------------------------------------------------------------------------------
Sintaxis
MPOSTOLC(<cTexto>, <nAnchura>, <nPos>,
[<nTama.oTabulador>], [<lSaltoL.nea>]) --> aL.neaColumna
Argumentos
<cTexto> es una cadena de texto.
<nAnchura> es la longitud de la línea formateada.
<nPos> es la posición de byte dentro del texto, contada a partir de
uno.
<nTama.oTabulador> es el número de columnas que hay entre las
posiciónes de tabulaci.n. Si no se especifica, el valor por defecto es
cuatro.
<lSaltoL.nea> es el indicador de salto autom.tico de línea. Si no se
especifica, el valor por defecto es verdadero (.T.).
Devuelve
MPOSTOLC() devuelve una matriz que contiene los valores de línea y de
columna de la posición de byte especificada, <nPos>.
Descripción
MPOSTOLC() es una función memo que determina la fila y columna
formateadas en <cTexto> que corresponden a una posición de byte
especificada. Recuerde que el número de fila devuelto se cuenta a partir
de uno, mientras que el número de columna se cuenta desde cero. Esta
función es compatible con MEMOEDIT(). <nPos> se cuenta a partir de uno,
lo que hace esta función compatible con AT(), RAT() y otras funciónes de
cadenas.
MPOSTOLC(), utilizada con MLCTOPOS(), permite crear rutinas de b.squeda
u otros procedimientos de texto para MEMOEDIT(). Consulte el código
fuente del Editor de Programas que se encuentra en el directorio
\CLIPPER5\SOURCE\PE.
Ejemplos
. Para la cadena de texto indicada, este ejemplo determina la
fila y la columna correspondientes al octavo carácter del texto, dada
una anchura de formato de cinco columnas. Una anchura de formato de
cinco columnas hace que las tres primeras palabras se coloquen cada
una en una línea distinta. El octavo carácter del texto es la "l" de
"lado." La palabra "lado" estar.a en la columna situada m.s a la
izquierda de la tercera línea del texto formateado; por tanto, el
valor de retorno es {3, 0}:
cText := "Mire el lado del pan donde"+;
"debe ponerse la mantequilla."
//
aLC := MPOSTOLC(cText, 5, 8) // Resultado: {3, 0}
Ficheros: La biblioteca asociada es CLIPPER.LIB.
NETERR()
Determina si ha fallado alg.n mandato o función de red
------------------------------------------------------------------------------
Sintaxis
NETERR([<lNuevoError>]) --> lError
Argumentos
<lNuevoError>: Si se especifica, selecciona el valor que devuelve
NETERR() en el estado especificado. <lNuevoError> puede ser verdadero
(.T.) o falso (.F.). El establecimiento de NETERR() en un valor
especificado permite al manejador de errores de ejecución controlar el
m.todo de manejo de determinados errores. Si desea más información,
consulte Errorsys.prg.
Devuelve
NETERR() devuelve verdadero (.T.) si ha fallado alg.n mandato USE o
APPEND BLANK. El valor inicial de NETERR() es falso (.F.). Si el proceso
actual no se ejecuta en un sistema operativo de red, NETERR() siempre
devuelve falso (.F.).
Descripción
NETERR() es una función de red. Se trata de un indicador global que
puede activarse por USE, USE...EXCLUSIVE y APPEND BLANK en un entorno de
red. Permite comprobar si ha fallado alguno de estos mandatos,
devolviendo verdadero (.T.) en las siguientes situaciones:
Causas de NETERR()
------------------------------------------------------------------------
Mandato Causa
------------------------------------------------------------------------
USE Abierto en modo exclusivo por otro proceso
USE...EXCLUSIVE Apertura en modo exclusivo o compartido por otro
proceso
APPEND BLANK Bloqueo por otro usuario con FLOCK() o RLOCK() de
LASTREC() + 1
------------------------------------------------------------------------
NETERR() se aplica normalmente a un programa para comprobarlo después de
aplicar un mandato USE o APPEND BLANK. Si devuelve falso (.F.), se puede
realizar la siguiente operación. Si el mandato es USE, se pueden abrir
ficheros ííndice. Si se trata de APPEND BLANK, pueden asignarse valores
al nuevo registro mediante un mandato REPLACE o @...GET. Si no devuelve
el valor falso, es necesario manejar el error, bien volviendo a intentar
el mandato USE o APPEND BLANK o finalizando la operación.actual con
BREAK o RETURN.
Ejemplos
. Este ejemplo muestra la forma de utilización de NETERR(). Si
el mandato USE concluye satisfactoriamente, se abren los ficheros
índice y el proceso continúa. Si el mandato USE falla, aparece un
mensaje y el control vuelve a la estructura BEGIN SEQUENCE m.s
cercana:
USE Cliente SHARED NEW
IF !NETERR()
SET INDEX TO NumCli, PedidosCli, CodPostCli
ELSE
? "Otro usuario est. utilizando el fichero"
BREAK
ENDIF
Ficheros: La biblioteca asociada es CLIPPER.LIB.
NETNAME()
Devuelve el código identificador de la estación de trabajo actual
------------------------------------------------------------------------------
Sintaxis
NETNAME() --> cNombreEstaci.nTrabajo
Devuelve
NETNAME() devuelve el código identificador de la estación de trabajo, en
forma de cadena con una longitud máxima de 15 carácteres. Si no se ha
establecido la estación de trabajo o la aplicación no est. operando en
una red de PCs IBM, devuelve una cadena nula ("").
Ejemplos
. El ejemplo siguiente muestra el resultado de NETNAME() al
arrancar una estación de trabajo como nodo de red con un
identificador de estación de "STATION 1":
? NETNAME() // Resultado: STATION 1
. El ejemplo siguiente muestra el resultado de NETNAME() al
arrancar una estación de trabajo como unidad independiente:
? NETNAME() // Resultado: ""
Ficheros: La biblioteca asociada es CLIPPER.LIB.
NETNAME()
Devuelve el código identificador de la estación de trabajo actual
------------------------------------------------------------------------------
Sintaxis
NETNAME() --> cNombreEstaci.nTrabajo
Devuelve
NETNAME() devuelve el código identificador de la estación de trabajo, en
forma de cadena con una longitud máxima de 15 carácteres. Si no se ha
establecido la estación de trabajo o la aplicación no est. operando en
una red de PCs IBM, devuelve una cadena nula ("").
Ejemplos
. El ejemplo siguiente muestra el resultado de NETNAME() al
arrancar una estación de trabajo como nodo de red con un
identificador de estación de "STATION 1":
? NETNAME() // Resultado: STATION 1
. El ejemplo siguiente muestra el resultado de NETNAME() al
arrancar una estación de trabajo como unidad independiente:
? NETNAME() // Resultado: ""
Ficheros: La biblioteca asociada es CLIPPER.LIB.
NEXTKEY()
Lee la siguiente tecla pendiente en la memoria intermedia del teclado
------------------------------------------------------------------------------
Sintaxis
NEXTKEY() --> nC.digoTecla
Devuelve
NEXTKEY() devuelve un valor numérico entero comprendido en el rango de
-39 a 386. Si la memoria intermedia del teclado est. vac.a, NEXTKEY()
devuelve cero. Si SET TYPEAHEAD es cero, NEXTKEY() siempre devuelve
cero.
Descripción
NEXTKEY() es una función que lee la siguiente tecla pendiente en la
memoria intermedia del teclado sin extraerla de la misma. El valor
devuelto es el código INKEY() de la tecla pulsada (INKEY() y LASTKEY()
devuelven el mismo valor). NEXTKEY() devuelve valores para todos los
carácteres ASCII, teclas de función y combinaciónes Alt-función,
Ctrl-función, Alt-letra y Ctrl-letra.
NEXTKEY() es similar a la función INKEY(), pero difiere en un aspecto
fundamental. INKEY() extrae la tecla pendiente de la memoria intermedia
del teclado y actualiza LASTKEY() con el valor de la tecla. NEXTKEY(),
por el contrario, lee la tecla de la memoria intermedia sin extraerla y
no actualiza LASTKEY().
Como NEXTKEY() no elimina la tecla de la memoria intermedia del teclado,
puede utilizarse para sondearlo y pasar el control a una rutina que
utilice un estado de espera o función INKEY() que recoja realmente la
tecla de la memoria.
Si desea una lista completa de los códigos de INKEY() y las constantes
del fichero Inkey.ch, consulte el apéíndice de Códigos Inkey de
CA-Clipper en la gu.a de Mensajes de Error y Apííndices.
Ejemplos
. Este ejemplo introduce una tecla Esc en la memoria intermedia
del teclado y muestra seguidamente las diferencias entre INKEY(),
LASTKEY() y NEXTKEY():
#include "Inkey.ch"
//
CLEAR TYPEAHEAD
KEYBOARD CHR(K_ESC)
//
? NEXTKEY(), LASTKEY() // Resultado: 27 0
? INKEY(), LASTKEY() // Resultado: 27 27
? NEXTKEY() // Resultado: 0
Ficheros: La biblioteca asociada es EXTEND.LIB,
el fichero de cabecera es Inkey.ch.
NOSNOW()
Activa/desactiva la supresión del efecto nieve en pantalla
------------------------------------------------------------------------------
Sintaxis
NOSNOW(<lActivar/Desactivar>) --> NIL
Argumentos
<lActivar/Desactivar> es un valor l.gico que intercambia el estado
actual de la supresión del efecto nieve. Un valor verdadero (.T.) activa
la supresión del efecto nieve, y un valor falso (.F.) la desactiva.
Descripción
NOSNOW() se utiliza para suprimir el efecto en los monitores CGA.
Normalmente, NOSNOW() aparece en la secci.n de configuración de su
aplicación para permitir al usuario suprimir el efecto nieve.
Ficheros: La biblioteca asociada es CLIPPER.LIB
OS()
Devuelve el nombre del sistema operativo
------------------------------------------------------------------------------
Sintaxis
OS() --> cNombreSO
Devuelve
OS() devuelve el nombre del sistema operativo en forma de cadena de
carácteres.
Descripción
OS() es una función de entorno que devuelve el nombre del sistema
operativo que se ejecuta en la estación de trabajo actual. El valor se
devuelve como el nombre del sistema operativo seguido del número de
versi.n.
Ejemplos
Este ejemplo utiliza OS() para indicar el sistema
operativo que se ejecuta en la estación de trabajo actual:
? OS() // Resultado: DOS 3.3
Ficheros: El fichero de biblioteca asociado es CLIPPER.LIB.
OUTERR()
Escribe una lista de valores en el dispositivo de errores estándar
------------------------------------------------------------------------------
Sintaxis
OUTERR(<lista exp>) --> NIL
Argumentos
<lista exp> es una lista de valores que aparecen en pantalla. Puede
estar formada por cualquier combinación de tipos de datos, incluyendo el
tipo memo.
Devuelve
OUTERR() siempre devuelve NIL.
Descripción
OUTERR() es id.ntica a OUTSTD(), excepto en que envía la salida al
dispositivo de error estándar, en vez de al dispositivo de salida
estándar. La salida envíada al dispositivo de error estándar evita los
dispositivos de consola y de salida de CA-Clipper, as. como cualquier
redirecci.n del DOS. Normalmente se utiliza para registrar mensajes de
error de forma que no interfieran con la salida en la pantalla o
impresora estándar.
Ejemplos
. Este ejemplo muestra en pantalla un mensaje de error junto con
la fecha y hora de su producci.n:
OUTERR("Fallo de bloqueo del fichero", DATE(), TIME())
Ficheros: El fichero de biblioteca asociado es CLIPPER.LIB.
OUTSTD()
Escribe una lista de valores en el dispositivo de salida estándar
------------------------------------------------------------------------------
Sintaxis
OUTSTD(<lista exp>) --> NIL
Argumentos
<lista exp> es una lista de valores que aparecen en pantalla. Puede
estar formada por cualquier combinación de tipos de datos, incluyendo el
tipo memo.
Devuelve
OUTSTD() siempre devuelve NIL.
Descripción
OUTSTD() es una función simple de salida similar a QOUT(), excepto en
que escribe en el dispositivo STDOUT (en vez de en la consola de CA-
Clipper). Los programas con requisitos de salida muy sencillos (es
decir, sin entrada o salida de pantalla completa) pueden utilizarse con
esta función para evitar recargar los subsistemas de salida de
terminales. El fichero de cabecera Simplio.ch redefine los mandatos ? y
?? para utilizar la función OUTSTD().
Como OUTSTD() envía su salida al dispositivo de salida estándar. La
salida puede redirigirse mediante los s.mbolos de redirecci.n del DOS
(>, |), lo que permite redirigir la salida de un programa de CA-Clipper
a un fichero o un encadenamiento de mandatos. Si desea más información
sobre esta función del sistema operativo, consulte su documentaci.n del
MS-DOS.
Ejemplos
. Este ejemplo utiliza OUTSTD() para mostrar en pantalla una
lista de expresiónes:
OUTSTD(Nombre, PADR(RTRIM(Ciudad) + "," + ;
Provincia, 20), CodPost)
. Este ejemplo redirige la salida de un programa de CA-Clipper a
un nuevo fichero mediante el operador de redirecci.n del DOS (>):
C>MYPROG > FILE.TXT
Ficheros: La biblioteca asociada es CLIPPER.LIB,
el fichero de cabecera es Simplio.ch.
PAD()
Llena valores de carácteres, fechas y numéricos con carácteres de relleno
------------------------------------------------------------------------------
Sintaxis
PADL(<exp>, <nLongitud>, [<cCarRelleno>]) --> cCadenaRellena
PADC(<exp>, <nLongitud>, [<cCarRelleno>]) --> cCadenaRellena
PADR(<exp>, <nLongitud>, [<cCarRelleno>]) --> cCadenaRellena
Argumentos
<exp> es el valor de carácteres, numérico o de fechas que se va a
rellenar.
<nLongitud> es la longitud de la cadena de carácteres que se va a
devolver.
<cCarRelleno> es el carácter con el que se va a rellenar <exp>. Si
no se especifica, el valor por defecto es carácteres de espacio.
Devuelve
PADC(), PADL() y PADR() devuelven como resultado una cadena formada por
<exp> y rellenada con <cCarRelleno> hasta una longitud total de
<nLongitud>.
Descripción
PADC(), PADL() y PADR() son funciónes que rellenan valores de
carácteres, fecha o numéricos con un carácter de relleno determinado
creando una nueva cadena de carácteres con una longitud especificada.
PADC() centra <exp> dentro de <nLongitud>, a.adiendo carácteres de
relleno en los extremos izquierdo y derecho; PADL() a.ade los carácteres
de relleno a la izquierda y PADR() los a.ade a la derecha. Si la
longitud de <exp> excede <nLongitud>, todas las funciónes PAD() truncan
cCadenaRellena en <nLongitud>.
PADC(), PADL() y PADR() muestran en pantalla cadenas de longitud
variable dentro de un .rea de longitud fija. Pueden utilizarse, por
ejemplo, para asegurar una alíneaci.n determinada al utilizar mandatos
?? consecutivos. Otra aplicación es para mostrar texto en un .rea de
pantalla de anchura fija y asegurarse de que el texto anterior se
sobreescriba completamente.
PADC(), PADL() y PADR() son las funciónes inversas de ALLTRIM(), RTRIM()
y LTRIM(), que eliminan los espacios iniciales y finales en blanco de
las cadenas de carácteres.
Ejemplos
. Este ejemplo utiliza PADR() para dar formato a la
visualización de un número de registro en una línea de estado,
rellenando el espacio asignado:
IF EOF()
@ 23, 45 PADR("EOF/" + LTRIM(STR(LASTREC())), 20)
ELSEIF BOF()
@ 23, 45 PADR("BOF/" + LTRIM(STR(LASTREC())), 20)
ELSE
@ 23, 45 SAY PADR("Registro " + LTRIM(STR(RECNO()) ;
+ "/" + LTRIM(STR(LASTREC())), 20)
ENDIF
Ficheros: La biblioteca asociada es EXTEND.LIB.
PCOL()
Devuelve la columna actual del cabezal de la impresora
------------------------------------------------------------------------------
Sintaxis
PCOL() --> nColumna
Devuelve
PCOL() devuelve un valor numérico entero que representa la posición de
la .ltima columna impresa m.s uno. La posición de columna inicial es
cero.
Descripción
PCOL() es una función que informa de la posición de columna del cabezal
de la impresora después de la .ltima operación. PCOL() sólo se actualiza
si SET DEVICE TO PRINTER o SET PRINTER ON están activados. PCOL() es
similar a COL(), excepto en se aplica a la impresora en vez de a la
pantalla. PCOL() se actualiza de las formas siguientes:
. Al arrancar la aplicación, PCOL() se pone a cero
. Al ejecutar un EJECT, PCOL() se pone a cero
. Cualquier operación.de impresión hace que PCOL() tome el valor
de la posición de la .ltima columna impresa m.s uno
. La función SETPRC() permite establecer PCOL() en la posición
de columna que se especifique
PCOL() se utiliza normalmente con PROW() e imprime un valor relativo al
último valor impreso en la misma línea. Esto facilita la alíneaci.n de
columnas durante la impresi.n de un informe de columnas. Para imprimir
un valor en la siguiente columna puede especificarse su posición como
PCOL() + <desplazamiento columna>. PCOL() sólo puede alínear
correctamente los valores en columnas cuando tienen una anchura fija.
Para asegurarse de que los valores tengan una anchura fija, d. formato a
la salida mediante la función TRANSFORM(), la cláusula PICTURE del
mandato @...SAY o cualquiera de las funciónes PAD().
Notas
. C.digos de control de impresora: Al envíar códigos de
control a la impresora, PCOL() deja de estar sincronizada con la
posición del cabezal de la impresora. Aunque los códigos de control
no se imprimen, la discrepancia ocurre porque CA-Clipper cuenta todos
los carácteres envíados a la impresora, independientemente de la
forma en que .sta los trate. Para evitar la discrepancia, guarde los
valores actuales de PROW() y PCOL(), env.e los códigos de control y
utilice SETPRC() para restablecer los valores originales de PROW() y
PCOL().
. SET MARGIN: PCOL() no puede utilizarse de manera fiable en
una sentencia SET MARGIN para imprimir con un mandato @...SAY. Al
imprimir con @...SAY, el valor actual de MARGIN se a.ade siempre a la
posición de columna especificada antes de envíar la salida a la
impresora. Esto hace que el valor MARGIN se sume al de PCOL() cada
vez que se invoca el mandato @...SAY en una misma línea de impresión.
Ejemplos
. En este ejemplo, PCOL() crea un informe sencillo que imprime
una lista de nombres, direcciones y números telef.nicos de clientes:
LOCAL nLinea := 99, nPagina := 1
USE Cliente INDEX NombreCli NEW
SET DEVICE TO PRINTER
DO WHILE !EOF()
IF nLinea > 55
PaginaSup(nPagina)
nLinea := 1
nPagina++
ENDIF
@ nLinea, 10 SAY NombreCli
@ nLinea, PCOL() + 2;
SAY RTRIM(Ciudad) + ", " + RTRIM(Provincia) + CodigoPost;
PICTURE REPLICATE("X", 35)
@ nLinea, PCOL() + 2;
SAY Telefono;
PICTURE "@R (999) 999-9999"
nLinea++
SKIP
ENDDO
SET DEVICE TO SCREEN
CLOSE
Ficheros: La biblioteca asociada es CLIPPER.LIB.
PCOUNT()
Determina la posición del último parámetro real pasado
------------------------------------------------------------------------------
Sintaxis
PCOUNT() --> nPosúltimoArgumento
Devuelve
PCOUNT() devuelve, como valor entero, la posición del último argumento
pasado. Si no se pasan argumentos, PCOUNT() devuelve cero.
Descripción
PCOUNT() informa de la posición del último argumento de la lista de
argumentos pasados al invocar un procedimiento o función. Esta
información es útil para determinar si se han dejado argumentos al final
de la lista de argumentos. El valor devuelto incluye, no obstante, los
argumentos omitidos en medio de la lista.
Para determinar si un parámetro no ha recibido un valor, compruebe si su
valor es NIL. Los parámetros omitidos no se inicializan y, por tanto,
devuelven NIL al acceder a ellos. Otro m.todo es comprobar los
parámetros con VALTYPE(). Esta función permite determinar si se ha
pasado un argumento y corregir su tipo simultáneamente. Si no se ha
pasado el parámetro, puede asign.rsele un valor por defecto.
Si desea más información sobre la forma de pasar parámetros, consulte el
capítulo Conceptos Básicos de la guía de Programación y Utilidades.
Ejemplos
. En este ejemplo, una función abre un fichero de base de datos
y utiliza PCOUNT() para determinar si el procedimiento invocante ha
pasado el nombre del fichero que se va a abrir. Si no se ha pasado el
nombre, la función AbrirFichero() lo pregunta:
FUNCTION AbrirFichero( cFichero )
IF PCOUNT() = 0
ACCEPT "Fichero que se va a utilizar: " TO cFichero
ENDIF
USE (cFichero)
RETURN (NETERR())
Ficheros: La biblioteca asociada es CLIPPER.LIB.
PROCLINE()
Devuelve el número de la línea del módulo fuente de la activaci.n actual o de
cualquiera de las anteriores
------------------------------------------------------------------------------
Sintaxis
PROCLINE([<nActivaci.n>]) --> nL.neaFuente
Argumentos
<nActivaci.n> es un valor numérico que especifica la activaci.n que
se va a examinar. Cero indica la activaci.n actual, uno la activaci.n
anterior, etc. Si no se especifica, el valor por defecto es cero.
Devuelve
PROCLINE() devuelve, como valor numérico entero, el número de la .ltima
línea ejecutada en el procedimiento, función o bloque de código que se
est. ejecutando. Si la opción de compilador /L suprime la información
del número de línea, PROCLINE() siempre devuelve cero.
Descripción
PROCLINE() examina la pila de activaciones de CA-Clipper para determinar
la .ltima línea ejecutada en el procedimiento, función o bloque de
código que se est. ejecutando actualmente. La pila de activaci.n es una
estructura interna que mantiene un registro de cada invocaci.n de
procedimiento, función o bloque de código. La numeraci.n de las líneas
comienza al principio del módulo fuente original. Cada línea incluye un
comentario, una línea en blanco, una directiva de preprocesador y una
continúa.ión de línea. Una línea de varias sentencias se cuenta como una
sola línea.
En la activaci.n actual, PROCLINE() devuelve el número de la línea
actual. En una activaci.n anterior, PROCLINE() devuelve el número de la
línea que invoc. al procedimiento o función que, a su vez, invoca a
PROCLINE().
Si la activaci.n que se examina es una evaluaci.n de bloque de código,
PROCLINE() devuelve el número de línea del procedimiento en el que se
defini. originalmente el bloque de código.
PROCLINE() se utiliza con PROCNAME() para generarála información de
depuraci.n.
Ejemplos
. En este ejemplo, PROCLINE() devuelve el número de línea de la
activaci.n actual, seguido del número de línea de la activaci.n
anterior:
// Primera línea del fichero fuente
Mifunción()
RETURN
FUNCTION Mifunción
? PROCLINE() // Resultado: 6 (activaci.n actual)
? PROCLINE(1) // Resultado: 2 (activaci.n anterior)
RETURN NIL
Ficheros: La biblioteca asociada es CLIPPER.LIB.
PROCNAME()
Devuelve el nombre de procedimiento o función actual o de cualquiera de los
anteriores
------------------------------------------------------------------------------
Sintaxis
PROCNAME([<nActivaci.n>]) --> cNombreProcedimiento
Argumentos
<nActivaci.n> especifica la activaci.n que se va a examinar. Un
valor cero indica la activaci.n actual, un valor uno la activaci.n
anterior, etc. Si no se especifica, el valor por defecto es cero.
Devuelve
PROCNAME() devuelve como cadena de carácteres el nombre del
procedimiento, función o bloque de código actualmente en ejecución.
Descripción
PROCNAME() examina la pila de activaci.n de CA-Clipper para determinar
el nombre del procedimiento, función o bloque de código en ejecución. La
pila de activaci.n es una estructura interna que mantiene un registro de
cada invocaci.n de procedimiento, función o bloque de código.
En la activaci.n actual, PROCNAME() devuelve el nombre del procedimiento
o función actual. En una activaci.n anterior, PROCNAME() devuelve el
nombre del procedimiento o función que, a su vez, ha invocado al
procedimiento actual.
Si la activaci.n que se examina es una evaluaci.n de bloque de código,
PROCNAME() devuelve el nombre del procedimiento o función que defini. el
bloque precedido por una (b). Si la activaci.n que se examina es una
variable de memoria, PROCNAME() devuelve el nombre precedido de M->.
PROCNAME() se utiliza con PROCLINE() para generaráinformación de
depuraci.n.
Ejemplos
. Este ejemplo es una función definida por el usuario que puede
invocarse durante una fase de depuraci.n del programa para mostrar en
pantalla la pila de activaci.n con los números de línea:
FUNCTION ListaPila( cMensaje )
LOCAL nActivacion := 1
? cMensaje
DO WHILE !(PROCNAME(nActivacion) == "")
? "Llamada desde:", PROCNAME(nActivacion),;
"(" + LTRIM(STR(PROCLINE(nActivacion))) + ")"
nActivacion++
ENDDO
QUIT
RETURN NIL
Ficheros: La biblioteca asociada es CLIPPER.LIB.
PROW()
Devuelve la fila actual del cabezal de la impresora
------------------------------------------------------------------------------
Sintaxis
PROW() --> nFila
Descripción
PROW() devuelve un valor numérico entero que representa la posición de
la .ltima fila impresa. La posición de fila inicial es cero.
Descripción
PROW() es una función que informa de la posición de fila del cabezal de
la impresora después de la .ltima operación. PROW() se actualiza
solamente si se ha establecido SET DEVICE TO PRINTER o SET PRINTER ON.
PROW() es similar a ROW(), excepto en que se aplica a la impresora, en
vez de a la pantalla. PROW() se actualiza de las formas siguientes:
. Al arrancar la aplicación, PROW() se pone a cero
. Al ejecutar un EJECT, PROW() se pone a cero
. Cualquier operación.de impresión hace que PROW() tome el valor
de la posición de la .ltima fila impresa
. La función SETPRC() permite establecer PROW() en la posición
de fila especificada
PROW() se utiliza normalmente con PCOL() e imprime un valor relativo al
último valor impreso en la misma línea. Si la cabeza de impresión se
coloca en una nueva fila con un código de control, salto de línea
(CHR(10)) o salto de p.gina (CHR(12)), PROW() no se actualiza y, por
tanto, no devuelve el valor previsto. Para evitar esta discrepancia,
desp.es de envíar cualquiera de estos valores a la impresora debe
utilizar la función SETPRC() para reinicializar PROW() con el valor
correcto.
Ejemplos
. Este ejemplo utiliza PROW() y SETPRC() para crear un programa
sencillo de etiquetas que se imprime con @...SAY, en vez de ?:
USE Cliente INDEX NombreCli NEW
SET DEVICE TO PRINTER
SETPRC(2, 0)
DO WHILE !EOF()
@ PROW(), 3 SAY NombreCli
@ PROW() + 1, 3 SAY RTRIM(Ciudad) + ",";
+ RTRIM(Provincia) + CodigoPost
@ PROW() + 1, 3 SAY Telefono ;
PICTURE "@R (999) 999-9999"
SETPRC(2, 0)
SKIP
ENDDO
SET DEVICE TO SCREEN
CLOSE
Ficheros: La biblioteca asociada es CLIPPER.LIB.
QOUT()
Muestra una lista de expresiónes en la salida estándar
------------------------------------------------------------------------------
Sintaxis
QOUT([<lista exp>]) --> NIL
QQOUT([<lista exp>]) --> NIL
Argumentos
<lista exp> es la lista de expresiónes (de cualquier tipo, excepto
matrices o bloques de código) separadas con comas que se va a mostrar en
la consola. Si se especifica QOUT() sin argumentos, se envía a la
consola un retorno de carro/salto de línea. Si se especifica QQOUT() sin
argumentos, no se muestra nada.
Devuelve
QOUT() y QQOUT() devuelven siempre NIL.
Descripción
QOUT() y QQOUT() son funciónes de consola. Estas funciónes son las
primitivas funciónales que crean los mandatos ? y ??, respectivamente.
Igual que los mandatos ? y ??, muestran en la consola los resultados de
una o más expresiónes. QOUT() envía algunos retornos de carro/saltos de
línea antes de mostrar los resultados de <lista exp>. QQOUT() muestra
los resultados de <lista exp> en la posición actual de ROW() y COL().
Cuando QOUT() y QQOUT() muestran su salida en la consola, se actualizan
los valores de las funciónes ROW() y COL(). Si SET PRINTER est.
activado, los valores que se actualizan son los de PROW() y PCOL(). Si
se especifica una <lista exp>, tanto QOUT() como QQOUT() insertan un
espacio entre los resultados de cada expresión.
QOUT() y QQOUT() pueden utilizarse para mostrar en la consola ciertos
valores dentro de una expresión. Esto es especialmente .til en bloques
de código, funciónes de iteraci.n, como AEVAL() y DBEVAL() y en listas
de sentencias en el formato de salida de una definición de mandato.
Ejemplos
. Este ejemplo utiliza QOUT() con AEVAL() para listar en la
consola el contenido de una matriz literal:
LOCAL aElementos := { 1, 2, 3, 4, 5 }
AEVAL(aElementos, { |elemento| QOUT(elemento) })
Ficheros: La biblioteca asociada es CLIPPER.LIB.
