RAT()
 Devuelve la posición de la .ltima aparici.n de una subcadena en una cadena
 dada
------------------------------------------------------------------------------
 Sintaxis

     RAT(<cB.squeda>, <cDestáno>) --> nPosici.n

 Argumentos

     <cB.squeda> es la cadena de carácteres que se desea buscar.

     <cDestáno> es la cadena de carácteres en la que se busca.

 Devuelve

     RAT() devuelve la posición de <cB.squeda> en <cDestáno>, en forma de
     valor numérico entero. Si <cB.squeda> no se encuentra, RAT() devuelve
     cero.

 Descripción

     RAT() es una función que devuelve la posición de la .ltima aparici.n de
     una subcadena de carácteres en otra cadena . Para ello, examina la
     cadena de destáno empezando por la derecha. RAT() es similar a la
     función AT(), que devuelve la posición de la primera aparici.n de una
     subcadena dentro de otra cadena. También es similar al operador $, que
     determina si una subcadena est. contenida en una cadena.

     Tanto la función RAT() como la función AT() se utilizan con SUBSTR(),
     LEFT() y RIGHT() para extraer subcadenas.

 Ejemplos

     .  Este ejemplo utiliza RAT() para crear una función,
        ViaFichero(), que extrae la vía de una especificación de fichero. Si
        no se especifica una vía, devuelve una cadena nula (""):

        ? ViaFichero("C:\DBF\Sales.dbf")      // Resultado: C:\DBF\

        FUNCTION ViaFichero(cFichero)
           LOCAL nPos, cViaFichero
           IF (nPos := RAT("\", cFichero)) != 0
              cViaFichero = SUBSTR(cFichero, 1, nPos)
           ELSE
              cViaFichero = ""
           ENDIF
           RETURN cViaFichero

 Ficheros: La biblioteca asociada es EXTEND.LIB.


 
READEXIT()
 Activa o desactiva las flechas Arriba y Abajo como teclas de salida del READ
------------------------------------------------------------------------------
 Sintaxis

     READEXIT([<lActivar/desactivar>]) --> lEstadoActual

 Argumentos

     <lActivar/desactivar> activa o desactiva la utilización de las
     flechas Arriba y Abajo como teclas de salida de un mandato READ. Si se
     especifica verdadero (.T.), se activan como teclas de salida y, si se
     especifica falso (.F.), se desactivan.

 Devuelve

     READEXIT() devuelve la selecci.n actual, en forma de valor l.gico.

 Descripción

     READEXIT() es una función de entorno que informa del estado actual de
     las flechas Arriba y Abajo como teclas de salida del mandato READ desde
     el primer o último objeto Get de una GetList. Si se especifica el
     argumento opciónal <lActivar/desactivar>, estas teclas se activan o
     desactivan como teclas de salida. Cuando se arranca el programa, Arriba
     y Abajo no están activadas como teclas de salida de READ. Normalmente,
     las teclas de salida de READ incluyen .nicamente ReP.g, AvP.g, Esc o
     Intro desde el último objeto GET.

 Ejemplos

     .  Este ejemplo muestra c.mo READEXIT() activa Arriba y Abajo
        como teclas de salida antes de un mandato READ y las desactiva al
        finalizar el mismo:

        cMiVar = SPACE(10)
        lUltimaSalida = READEXIT(.T.)      // Resultado:
                                           // Activa las teclas de salida
        @ 10, 10 SAY "Intro: " GET cMiVar
        READ
        READEXIT(lUltimaSalida)            // Resultado:
                                           // Restablece la selecci.n anterior

 Ficheros:  La biblioteca asociada es CLIPPER.LIB.

READINSERT()
 Activa o desactiva el modo de inserci.n para los mandatos READ y MEMOEDIT()
------------------------------------------------------------------------------
 Sintaxis

     READINSERT([<lActivar/desactivar>]) --> lModoActual

 Argumentos

     <lActivar/desactivar> activa o desactiva el modo de inserci.n.
     Verdadero (.T.) lo activa y falso (.F.) lo desactiva. El valor por
     defecto es falso (.F.) o el último modo seleccionado por el usuario con
     un mandato READ o MEMOEDIT().

 Devuelve

     READINSERT() devuelve el estado actual del modo de inserci.n, en forma
     de valor l.gico.

 Descripción

     READINSERT() es una función de entorno que informa del estado actual del
     modo de inserci.n de los mandatos READ y MEMOEDIT() y, opciónalmente, lo
     activa o desactiva, dependiendo del valor de <lActivar/desactivar>. Si
     READINSERT() devuelve falso (.F.), los carácteres se sobreescriben al
     introducir el usuario carácteres en la memoria intermedia de un objeto
     mediante un mandato READ o MEMOEDIT(). Si READINSERT() devuelve
     verdadero (.T.), los carácteres introducidos se insertan. El modo de
     inserci.n pertenece a la configuración global del sistema y no a un
     objeto determinado.

     READINSERT() puede ejecutarse antes o durante un mandato READ o
     MEMOEDIT(). Si se utiliza con READ, READINSERT() puede invocarse en una
     cláusula WHEN o VALID de @...GET o en un procedimiento SET KEY. Si se
     utiliza con MEMOEDIT(), puede invocarse con la función de usuario, as.
     como con un procedimiento SET KEY.

 Ejemplos

     .  Este ejemplo fija el modo de inserci.n antes de entrar en
        MEMOEDIT() y reinicializa el modo cuando MEMOEDIT() finaliza:

        USE Ventas NEW

        // Activar el modo de inserci.n
        lModoIns = READINSERT(.T.)
        Ventas->Notas := MEMOEDIT(Ventas->Notas)
        // Restablecer el modo de inserci.n anterior
        READINSERT(lModoIns)

 Ficheros:  La biblioteca asociada es CLIPPER.LIB.

READKEY()*
 Determina qu. tecla ha finalizado un mandato READ
------------------------------------------------------------------------------
 Sintaxis

     READKEY() --> nC.digoTeclaRead

 Devuelve

     READKEY() devuelve un código que representa la tecla que se ha pulsado
     para salir de un READ. En CA-Clipper, las siguientes son las teclas de
     salida estándar de READ y sus códigos de retorno READKEY():

     C.digos de Retorno de READKEY()
     ------------------------------------------------------------------------
     Tecla de Salida              C.digo de Retorno
     ------------------------------------------------------------------------
     Arriba                        5
     Abajo                         2
     ReP.g                         6
     AvP.g                         7
     Ctrl-ReP.g                   31
     Ctrl-AvP.g                   30
     Esc                          12
     Ctrl-Fin, Ctrl-W             14
     Escribir m.s all. del fin    15
     Intro                        15
     ------------------------------------------------------------------------

 Descripción

     READKEY() es una función de teclado que emula a la función READKEY() de
     dBASE III PLUS. Su finalidad es determinar qu. tecla ha pulsado el
     usuario para finalizar un READ. Si UPDATED() es verdadero (.T.),
     READKEY() devuelve el código m.s 256. S.lo pueden utilizarse Arriba y
     Abajo para salir de un mandato READ si READEXIT() vale verdadero (.T.).
     El valor por defecto es falso (.F.). Para permitir una completa
     compatibilidad de estas teclas, ejecute READEXIT (.T.) al principio de
     su procedimiento principal.

     READKEY() se incluye como función de compatibilidad, por lo que su
     utilización no es recomendable. Puede sustituirse completamente por
     LASTKEY(), que determina la .ltima pulsaci.n obtenida de la memoria
     intermedia del teclado. Si la pulsaci.n fue una tecla de salida de READ,
     LASTKEY() devuelve el código de INKEY() de esta tecla. Para determinar
     si se ha modificado la memoria intermedia de un objeto Get durante un
     READ, puede sustituirse por la función UPDATED().

 Ficheros:  La biblioteca asociada es EXTEND.LIB,
            el fichero fuente es SOURCE\SAMPLE\READKEY.PRG

READMODAL()
 Activa el modo de edici.n de pantalla completa de la GetList
------------------------------------------------------------------------------
 Sintaxis

     READMODAL(<aGetList>) --> NIL

 Argumentos

     <aGetList> es una matriz que contiene la lista de objetos Get que se
     van a editar.

 Devuelve

     READMODAL() devuelve siempre NIL.

 Descripción

     READMODAL() es una función de interfaz de usuario que activa el modo de
     pantalla completa para objetos GET. Forma parte del sistema Get de
     arquitectura abierta de CA-Clipper. READMODAL() es similar al mandato
     READ, excepto en que toma una matriz GetList como argumento y no
     reinicializa la matriz cuando finaliza. Debido a esto, es posible
     utilizar m.ltiples listas de objetos Get y activarlas en cualquier
     momento de la ejecución de un programa, siempre que la matriz que se va
     a utilizar est. visible.

     Por compatibilidad con las versiones anteriores de CA-Clipper, el
     sistema GET utiliza una matriz pública llamada GetList. Cada vez que se
     ejecuta un mandato @...GET, .ste crea un objeto Get y lo a.ade a la
     matriz GetList actualmente visible. El mandato READ estándar se
     preprocesa mediante una llamada a READMODAL(), que utiliza la matriz
     GetList como argumento. Si no se especifica la cláusula SAVE, se asigna
     a la variable GetList una matriz vac.a cuando finaliza READMODAL().

     Algunas de las funciónes de Getsys.prg se han hecho públicas para que
     puedan utilizarse con otros sistemas Get personalizados. En la siguiente
     tabla se listan estas funciónes.

     funciónes del Sistema Get
     ------------------------------------------------------------------------
     función             Descripción
     ------------------------------------------------------------------------
     GETACTIVE()         Devuelve el objeto Get actualmente activo
     GETAPPLYKEY()       Aplica una tecla a un objeto Get desde una rutina de
                         lectura del Get
     GETDOSETKEY()       Procesa SET KEY durante la edici.n del objeto GET
     GETPOSTVALIDATE()   Eval.a la postcondición del objeto Get actual
     GETPREVALIDATE()    Eval.a la precondición del objeto Get actual
     GETREADER()         Ejecuta las acciones READ estándares para un objeto
                         Get
     READFORMAT()        Devuelve, y opciónalmente establece, el bloque de
                         código que define un fichero de formato (.fmt)
     READKILL()          Devuelve, y opciónalmente establece, si debe salirse
                         del Read actual
     READUPDATED()       Devuelve, y opciónamente establece, si un objeto Get
                         se ha modificado durante un Read
     ------------------------------------------------------------------------

     Si desea información sobre los objetos Get y las funciónes antes
     listadas, consulte el capítulo El Sistema Get de la guía de Programación
     y Utilidades.

     Si desea más información sobre las teclas que pueden utilizarse por
     defecto con la función READMODAL(), consulte la referencia del mandato
     READ de este capítulo.

 Ficheros:  La biblioteca asociada es CLIPPER.LIB,
            el fichero fuente es SOURCE\SYS\GETSYS.PRG


READVAR()
 Devuelve el nombre de la variable del Get o del Men. actual
------------------------------------------------------------------------------
 Sintaxis

     READVAR() --> cNombreVar

 Devuelve

     READVAR() devuelve el nombre de la variable asociada con el objeto Get
     actual o el de la variable asignada mediante el mandato MENU TO, como
     una cadena de carácteres en mayúsculas.

 Descripción

     READVAR() es una función de entorno que se utiliza, fundamentalmente,
     para generaráayudas sensibles al contexto para objetos Get y men.s de
     barra. READVAR() sólo puede utilizarse con los mandatos READ o MENU TO.
     Si se utiliza durante cualquier otro estado de espera, como ACCEPT,
     INPUT, WAIT, ACHOICE(), DBEDIT() o MEMOEDIT(), devuelve una cadena nula
     (""). Es habitual acceder a ella desde un procedimiento SET KEY o
     función invocada con una cláusula WHEN o VALID de un objeto Get.

 Ejemplos

     .  Este ejemplo crea un sistema sencillo de ayuda para objetos
        Get, utilizando un fichero de base de datos para almacenar el texto
        de ayuda. Cuando el usuario pulsa F1, se busca en el fichero
        utilizando READVAR() como valor clave y, si existe texto de ayuda, se
        muestra en una ventana:

        #include "Inkey.ch"
        //
        SET KEY K_F1 TO ConsultaAyuda
        cCadena = SPACE(10)
        @ 5, 5 SAY "Intro:" GET cCadena
        READ
        RETURN

        FUNCTION ConsultaAyuda
           USE Ayuda INDEX Ayuda NEW
           SEEK READVAR()
           IF FOUND()
              MostrarAyuda(Ayuda->Tema)
           ELSE
              MostrarAyuda("No hay ayuda sobre " + READVAR())
           ENDIF
           CLOSE Ayuda
           RETURN NIL

        FUNCTION MostrarAyuda(cTema)
           LOCAL cPantalla := SAVESCREEN(5,5,15,70),;
                  cColor := SETCOLOR("BG+/B")
           //
           SET CURSOR OFF
           @ 5, 5 CLEAR TO 15, 70
           @ 5, 5 TO 15, 70 DOUBLE
           @ 5, 30 SAY " Ayuda para " + READVAR() + " "
           MEMOEDIT(cTema, 6, 7, 14, 68, .F.)
           //
           RESTSCREEN(5, 5, 15, 70, cPantalla)
           SETCOLOR(cColor)
           SET CURSOR ON
           //
           RETURN NIL

 Ficheros:  La biblioteca asociada es CLIPPER.LIB.


RECCOUNT()*
 Determina el número de registros del fichero (.dbf) actual
------------------------------------------------------------------------------
 Sintaxis

     RECCOUNT()* | LASTREC() --> nRegistros

 Devuelve

     RECCOUNT() devuelve el número de registros f.sicos existentes en el
     fichero actual de base de datos, en forma de valor numérico entero. Los
     mandatos de filtro como SET FILTER o SET DELETED no afectan al valor
     devuelto. RECCOUNT() devuelve cero si no hay ningún fichero de base de
     datos abierto en el área de trabajo actual.

 Descripción

     RECCOUNT() es una función de base de datos similar a LASTREC(). Por
     defecto, RECCOUNT() opera en el área de trabajo actual. Si desea
     utilizarla en otra área de trabajo, debe especificarla mediante una
     expresión de alias (consulte el ejemplo siguiente).

 Ejemplos

     .  Este ejemplo ilustra la relaci.n que existe entre COUNT y
        RECCOUNT():

        USE Ventas NEW
        ? RECCOUNT()                        // Resultado: 84
        //
        SET FILTER TO Vendedor = "1001"
        COUNT TO nRegistros
        ? nRegistros                        // Resultado: 14
        ? RECCOUNT()                        // Resultado: 84

     .  Este ejemplo utiliza una expresión de alias para acceder al
        número de registros de un área de trabajo no seleccionada:

        USE Ventas NEW
        USE Cliente NEW
        ? RECCOUNT(), Ventas->(RECCOUNT())

 Ficheros:  La biblioteca asociada es CLIPPER.LIB.

RECNO()
 Devuelve el número del registro actual de un área de trabajo
------------------------------------------------------------------------------
 Sintaxis

     RECNO() --> nRegistro

 Devuelve

     RECNO() devuelve el número del registro actual, en forma de valor
     numérico entero. Si el área de trabajo contiene un fichero con cero
     registros, RECNO() devuelve uno, BOF() y EOF() devuelven verdadero (.T.)
     y LASTREC() devuelve cero.

     Si el puntero se desplaza m.s all. del último registro, RECNO() devuelve
     LASTREC() + 1 y EOF() devuelve verdadero (.T.). Si se intenta desplazar
     antes del primer registro, RECNO() devuelve el número del primer
     registro l.gico del fichero de base de datos y BOF() devuelve verdadero
     (.T.). Si no hay un fichero de base de datos abierto, RECNO() devuelve
     cero.

 Descripción

     RECNO() es una función de base de datos que devuelve el número del
     registro actual de un área de trabajo. En el esquema de ficheros de base
     de datos de CA-Clipper, todos los ficheros se ordenan f.sicamente por
     los números de registro. A su vez, todas las áreas de trabajo tienen un
     puntero en el registro actual de su fichero abierto. RECNO() informa de
     este número de registro. La numeraci.n permite accerder directamente a
     un registro sin tener que examinar todo el fichero para llegar al
     registro especificado.

     RECNO() se utiliza normalmente con rutinas que procesan los registros
     por su número. Estas incluyen SET RELATION...TO RECNO(), que enlaza
     ficheros de base de datos por números de registro. GO RECNO() actualiza
     también los datos del registro actual del disco.

     Por defecto, RECNO() opera en el área de trabajo actual. Si desea
     utilizarla en un área de trabajo no seleccionada, debe especificarla en
     una expresión de alias (consulte el ejemplo siguiente).

 Ejemplos

     .  Este ejemplo consulta RECNO() tras desplazar intencionadamente
        el puntero de registro:

        USE Clientes NEW
        GO 3
        ? RECNO()                        // Resultado: 3
        GO TOP
        ? RECNO()                        // Resultado: 1
        nRegistro := 3
        GO nRegistro
        ? RECNO()                        // Resultado: 3
        GO BOTTOM
        SKIP
        ? RECNO(), LASTREC()             // Resultado: 11 10

     .  Este ejemplo utiliza expresiónes de alias para obtener el
        valor de RECNO() en .reas de trabajo no seleccionadas:

        USE Ventas NEW
        USE Cliente NEW
        //
        ? Ventas->(RECNO())
        ? Cliente->(RECNO())

 Ficheros:  La biblioteca asociada es CLIPPER.LIB.


RECSIZE()
 Determina el tama.o de un registro de un fichero de base de datos (.dbf)
------------------------------------------------------------------------------
 Sintaxis

     RECSIZE() --> nBytes

 Devuelve

     RECSIZE() devuelve, como valor numérico entero, la longitud en bytes de
     un registro del fichero de base de datos abierto en el área de trabajo
     actual. Si no hay un fichero de base de datos abierto, RECSIZE()
     devuelve cero.



 Descripción

     RECSIZE() es una función de base de datos que determina la longitud de
     un registro, sumando lasólongitudes de cada campo y, a continúa.ión, uno
     para el indicador de estado DELETED(). Si este valor se multiplica por
     LASTREC(), el resultado es el espacio ocupado por todos los registros
     del fichero.

     RECSIZE() es útil en programas que realicen autom.ticamente copias de
     seguridad del fichero. Si se utiliza con DISKSPACE(), la función
     RECSIZE() permite comprobar la existencia de espacio libre suficiente en
     el disco antes de guardar un fichero.

     Por defecto, RECSIZE() opera en el área de trabajo actual. Si desea
     utilizarla en un área de trabajo no seleccionada, debe especificarla en
     una expresión de alias (consulte el ejemplo siguiente).

 Ejemplos

     .  La siguiente función, TamanoDbf(), utiliza RECSIZE() para
        calcular el tama.o del fichero actual de base de datos:

        FUNCTION TamanoDbf
           RETURN ((RECSIZE() * LASTREC()) + HEADER() + 1)

     .  Este ejemplo muestra la forma de utilización de RECSIZE() para
        determinar la longitud de registro de un fichero abierto en un .rea
        de trabajo no seleccionada.

        USE Cliente NEW
        USE Ventas NEW
        //
        ? RECSIZE(), Cliente->(RECSIZE())
        ? TamanoDbf(), Cliente->(TamanoDbf())

 Ficheros:  La biblioteca asociada es EXTEND.LIB.


REPLICATE()
 Devuelve una cadena, repetida el número de veces especificado
------------------------------------------------------------------------------
 Sintaxis

     REPLICATE(<cCadena>, <nVeces>) --> cCadenaRepetida

 Argumentos

     <cCadena> es la cadena de carácteres que se va a repetir.

     <nVeces> es el número de veces que se va a repetir <cCadena>.

 Devuelve

     REPLICATE() devuelve una cadena de carácteres de una longitud máxima de
     65.535 (64K) bytes. Si se especifica cero como argumento <nVeces>,
     devuelve una cadena nula ("").

 Descripción

     REPLICATE() es una función de carácteres que muestra, imprime o llena la
     memoria del teclado con uno o m.s carácteres repetidos. REPLICATE() es
     similar a la función SPACE(), que devuelve el número especificado de
     carácteres de espacio.

 Ejemplos

     .  Estos ejemplos muestran la repetición de cadenas por medio de
        REPLICATE():

        ? REPLICATE("*", 5)            // Resultado: *****
        ? REPLICATE("Hola", 2)         // Resultado: Hola Hola
        ? REPLICATE(CHR(42), 5)        // Resultado: *****

     .  Este ejemplo utiliza REPLICATE() para llenar la mamoria del
        teclado con varias flechas Abajo:

        #include "Inkey.ch"
        KEYBOARD REPLICATE(CHR(K_DN), 25)

 Ficheros:  La biblioteca asociada es CLIPPER.LIB.

RESTSCREEN()
 Muestra una zona de pantalla prevíamente guardada, en la posición
 especificada
------------------------------------------------------------------------------
 Sintaxis

     RESTSCREEN([<nSuperior>], [<nIzquierda>], [<nInferior>],
                [<nDerecha>], <cPantalla>) --> NIL

 Argumentos

     <nSuperior>, <nIzquierda>, <nInferior> y <nDerecha>
     definen las coordenadas de la información de pantalla contenida en
     <cPantalla>. Si no se especificaron coordenadas con <cPantalla> para que
     se guardara toda la pantalla, tampoco son necesarias con RESTSCREEN().

     <cPantalla> es una cadena de carácteres que contiene la zona de
     pantalla guardada.

 Devuelve

     RESTSCREEN() devuelve siempre NIL.

 Descripción

     RESTSCREEN() es una función que vuelve a mostrar una zona de pantalla
     guardada con SAVESCREEN(). La posición de destáno puede ser la posición
     de pantalla original u otra diferente. Si se especifica una nueva
     posición, la nueva zona debe tener el mismo tama.o que la antigua o se
     obtendr.n resultados ambiguos. Al utilizar RESTSCREEN() para recuperar
     secciones de pantalla guardadas con SAVE SCREEN, pueden especificarse
     coordenadas comprendidas entre 0, 0,y MAXROW(), MAXCOL().

     .Advertencia! SAVE SCREEN, RESTORE SCREEN, SAVESCREEN() y
     RESTSCREEN() sólo pueden utilizarse con el controlador de pantalla por
     defecto. Otros controladores pueden no permitir guardar y recuperar las
     pantallas.

 Ejemplos

     .  Este ejemplo muestra RESTSCREEN() como parte de una función de
        men. emergente de uso general, MenuEmerg():

        ? MenuEmerg({1, 1, 3, 10, {"ElementoUno", "ElementoDos"}, ;
              "BG+/B"})

        FUNCTION MenuEmerg(aLista)
           LOCAL cPantalla, nSeleccion, cAntiguoColor := ;
                    SETCOLOR(aLista[6])
           cPantalla := SAVESCREEN(aLista[1], aLista[2],;
               aLista[3], aLista[4])
           @ aLista[1], aLista[2] TO aLista[3], aLista[4] DOUBLE
           nSeleccion := ACHOICE(++aLista[1], ++aLista[2],;
              --aLista[3], --aLista[4], aLista[5])
           SETCOLOR(cAntiguoColor)
           RESTSCREEN(--aLista[1], --aLista[2], ++aLista[3],;
               ++aLista[4], cPantalla)
           RETURN nSeleccion

 Ficheros: La biblioteca asociada es EXTEND.LIB.

RIGHT()
 Devuelve una subcadena, comenzando por el carácter situado m.s a la derecha
------------------------------------------------------------------------------
 Sintaxis

     RIGHT(<cCadena>, <nPosiciones>) --> cSubCadena

 Argumentos

     <cCadena> es la cadena de carácteres de la que se extraen los
     carácteres.

     <nPosiciones> es el número de carácteres que se van a extraer.

 Devuelve

     RIGHT() devuelve <nPosiciones> carácteres, contados desde el extremo
     derecho de <cCadena>. Si <nPosiciones> es cero, RIGHT() devuelve una
     cadena nula (""). Si <nPosiciones> es un número negativo o mayor que la
     longitud de la cadena de carácteres, RIGHT() devuelve <cCadena>. El
     máximo tama.o de una cadena es de 65.535 (64K) bytes.

 Descripción

     RIGHT() es una función de carácteres que extrae una subcadena comenzando
     por el carácter situado m.s a la derecha de <cCadena>. Es id.ntica a la
     expresión de carácteres SUBSTR(<cCadena>, -<nPosiciones>). Por ejemplo,
     RIGHT("ABC", 1) esólo mismo que SUBSTR("ABC", -1). RIGHT() est.
     relacionada con LEFT(), que extrae una subcadena comenzando por el
     carácter m.s a la izquierda de <cCadena>.

     Las funciónes RIGHT(), LEFT() y SUBSTR() se utilizan frecuentemente con
     las funciónes AT() y RAT() para localizar la primera y/o .ltima posición
     de una subcadena antes de extraerla.

 Ejemplos

     .  Este ejemplo muestra la relaci.n que existe entre RIGHT() y
        SUBSTR():

        ? RIGHT("ABCDEF", 3)                       // Resultado: DEF
        ? SUBSTR("ABCDEF", -3)                     // Resultado: DEF

     .  Este ejemplo extrae una subcadena, desde el final de otra
        cadena hasta la .ltima aparici.n de una coma:

        LOCAL cNombre := "Jaime,Guillermo"
        ? RIGHT(cNombre,;
        LEN(cNombre) - RAT(",", cNombre) - 1)      // Resultado: Guillermo

 Ficheros:  La biblioteca asociada es EXTEND.LIB.

RLOCK()
 Bloquea el registro actual del área de trabajo activa
------------------------------------------------------------------------------
 Sintaxis

     RLOCK() --> lExito

 Devuelve

     RLOCK() devuelve verdadero (.T.) si se bloquea el registro; y falso
     (.F.) en caso contrario.

 Descripción

     RLOCK() es una función de red que bloquea el registro actual, impidiendo
     que otros usuarios puedan actualizar ese registro hasta que se libere.
     RLOCK() permite un bloqueo compartido y los otros usuarios tienen acceso
     de sólo lectura al registro bloqueado. S.lo se permite modificarlo al
     usuario actual. El bloqueo de registro se mantiene hasta que se bloquee
     otro registro, se ejecute un mandato UNLOCK, se cierre el fichero de
     base de datos o se ejecute un FLOCK() en el fichero actual.

     Por cada invocaci.n de RLOCK(), se realiza un intento de bloquear el
     registro actual y el resultado se devuelve como valor l.gico. Los
     intentos de bloqueo de un registro fallan cuando otro usuario ha
     bloqueado o est. utilizando en modo exclusivo el fichero actual. Si se
     intenta ejecutar RLOCK() en una base de datos vac.a, se devuelve
     verdadero (.T.).

     Por defecto, RLOCK() opera en el área de trabajo actual. Si desea
     utilizarla en un área de trabajo no seleccionada, debe especificarla en
     una expresión de alias (consulte el ejemplo siguiente). Esto puede ser
     muy .til porque RLOCK() no intenta autom.ticamente bloquear los
     registros de ficheros relacionados.

     Normalmente, RLOCK() opera .nicamente en el registro actual. Esto
     incluye los siguientes mandatos:

     .  @...GET

     .  DELETE (un registro)

     .  RECALL (un registro)

     .  REPLACE (un registro)

     Si desea más información, consulte el capítulo Programaci.n en Red de la
     guía de Programación y Utilidades.

 Notas

     .  SET RELATION: CA-Clipper no bloquea autom.ticamente todos
        los registros de la cadena de relaci.n cuando el usuario bloquea el
        registro del área de trabajo actual. Asimismo, un mandato UNLOCK no
        afecta a las .reas de trabajo relacionadas.

 Ejemplos

     .  Este ejemplo borra un registro en un entorno de red utilizando
        RLOCK():

        USE Clientes INDEX NombreCli SHARED NEW
        SEEK "Martinez"
        IF FOUND()
           IF RLOCK()
              DELETE
              ? "Martinez ha sido borrado"
           ELSE
              ? "Otro usuario est. utilizando el registro"
           ENDIF
        ELSE
           ? "Martinez no se encuentra en el fichero Clientes"
        ENDIF
        CLOSE

     .  Este ejemplo especifica RLOCK() en una expresión de alias para
        bloquear un registro en un área de trabajo no seleccionada:

        USE Ventas SHARED NEW
        USE Clientes SHARED NEW
        //
        IF !Ventas->(RLOCK())
           ? "Otro usuario est. utilizando el registro Ventas actual"
        ENDIF

 Ficheros:  La biblioteca asociada es CLIPPER.LIB.


ROUND()
 Devuelve un valor numérico, redondeado con el número de cifras especificado
------------------------------------------------------------------------------
 Sintaxis

     ROUND(<nNúmero>, <nDecimales>) --> nRedondeado

 Argumentos

     <nNúmero> es el valor numérico que se va a redondear.

     <nDecimales> define el número de decimales que se mantienen. Si se
     especifica un valor negativo, se redondean números enteros.

 Devuelve

     ROUND() devuelve un valor numérico.

 Descripción

     ROUND() es una función numérica que redondea <nNúmero> con el número de
     decimales especificado con <nDecimales>. Si se especifica cero o un
     valor negativo en <nDecimales> se redondea el número entero. Un valor
     negativo de <nDecimales> indica el número de cifras a la izquierda de la
     coma decimal que se van a redondear. Las cifras entre cinco y nueve,
     ambos inclusive, se redondean por encima y las cifras inferiores a cinco
     se redondean por debajo.

     La visualización del valor devuelto no obedece el valor de DECIMALS, a
     menos que se haya establecido SET FIXED ON. Si se ha establecido SET
     FIXED OFF, la visualización del valor devuelto contiene tantas cifras
     decimales como las especificadas en <nDecimales> o cero, si <nDecimales>
     es menor de uno.

 Ejemplos

     .  Estos ejemplos redondean valores con cifras decimales:

     SET DECIMALS TO 2
        SET FIXED ON
        //
        ? ROUND(10.4, 0)                 // Resultado: 10.00
        ? ROUND(10.5, 0)                 // Resultado: 11.00
        ? ROUND(10.51, 0)                // Resultado: 11.00
        ? ROUND(10.49999999999999, 2)    // Resultado: 10.50

     .  Estos ejemplos utilizan un argumento <nDecimales> negativo y
        redondean valores numéricos en números enteros:

        ? ROUND(101.99, -1)              // Resultado: 100.00
        ? ROUND(109.99, -1)              // Resultado: 110.00
        ? ROUND(109.99, -2)              // Resultado: 100.00

 Ficheros:  La biblioteca asociada es CLIPPER.LIB.


ROW()
 Devuelve la fila actual del cursor
------------------------------------------------------------------------------
 Sintaxis

     ROW() --> nFila

 Devuelve

     ROW() devuelve la posición de fila del cursor, en forma de valor
     numérico entero. El rango del valor devuelto es de cero a MAXROW().

 Descripción

     ROW() es una función de pantalla que devuelve la posición de fila o
     línea actual del cursor en la pantalla. El valor de ROW() se actualiza
     por los mandatos y funciónes, tanto de consola como de pantalla
     completa. @...SAY sólo actualiza ROW() cuando se ha establecido SET
     DEVICE TO SCREEN.

     ROW() se utiliza con COL() y todas las variantes del mandato @ para
     colocar el cursor en una nueva línea respecto a la línea actual. En
     concreto, ROW() y COL() pueden utilizarse para crear procedimientos y
     funciónes de posición independiente, en los que la fila y columna
     superior izquierda se pasan como parámetros.

     ROW() está relacionada con PROW() y PCOL(), que controla la posición
     actual del cabezal de la impresora en vez de la posición del cursor.

 Ejemplos

     .  En este ejemplo, ROW() simula el mandato LIST, mostrando el
        texto en la misma línea, pero en diferentes columnas:

        LOCAL nFila
        USE Cliente INDEX NombreCli NEW
        DO WHILE .NOT. EOF()
           CLS
           @ 1, 1 SAY PADR("Nombre" LEN(CNombreCli))
           @ ROW(), COL() + 2 SAY PADR("Direccion", ;
                 LEN(Direccion))
           @ ROW(), COL() + 2 SAY PADR("Tel.fono", LEN(Telefono))
           nFila = 0
           DO WHILE nFila++ <= 15 .AND. (!EOF())
              @ ROW() + 1, 1 SAY NombreCli
              @ ROW(), COL() + 2 SAY Direccion
              @ ROW(), COL() + 2 SAY Telefono
              SKIP
           ENDDO
           WAIT
        ENDDO
        CLOSE Cliente

 Ficheros:  La biblioteca asociada es CLIPPER.LIB.

RTRIM()
 Suprime los espacios finales de una cadena de carácteres
------------------------------------------------------------------------------
 Sintaxis

     [R]TRIM(<cCadena>) --> cCadenaSuprim

 Argumentos

     <cCadena> es la cadena de carácteres que se va a copiar sin espacios
     finales.

 Devuelve

     RTRIM() devuelve una copia de <cCadena> sin espacios finales. Si
     <cCadena> es una cadena nula ("") o todo espacios, RTRIM() devuelve una
     cadena nula ("").

 Descripción

     RTRIM() es una función que formatea cadenas de carácteres. Sirve para
     borrar espacios finales al concatenar cadenas, lo que ocurre con mucha
     frecuencia en los campos de base de datos que se almacenan con un
     formato de anchura fija. Por ejemplo, RTRIM() puede utilizarse para
     concatenar los campos que contienen el nombre y el apellido para formar
     una cadena con el nombre completo.

     RTRIM() está relacionada con LTRIM(), que suprime los espacios
     iniciales, y con ALLTRIM(), que suprime tanto los espacios iniciales
     como los finales. Las funciónes inversas de ALLTRIM(), LTRIM() y RTRIM()
     son PADC(), PADR() y PADL(), que centra, justifica a la derecha o
     justifica a la izquierda, respectivamente, las cadenas de carácteres,
     rellen.ndolas con carácteres de relleno.

 Ejemplos

     .  Esta es una función en la que RTRIM() formatea los campos
        Ciudad, Provincia y C.digo postal para etiquetas y circulares:

        FUNCTION Direccion(cCiudad, cProvincia, cCodigoPostal)
           RETURN RTRIM(cCiudad) + ", " ;
            + RTRIM(cProvincia) + " " + cCodigoPostal

     .  En este ejemplo, la función, Direccion(), muestra un registro
        de Clientes.dbf:

        USE Clientes INDEX NombreCli NEW
        SEEK "Rosa"
        ? Direccion(Ciudad, Provincia, CodigoPostal)
        // Resultado: Oviedo, Asturias 43066

 Ficheros:  La biblioteca asociada es CLIPPER.LIB.

SAVESCREEN()
 Guarda una parte de la pantalla para su posterior visualización
------------------------------------------------------------------------------
 Sintaxis

     SAVESCREEN([<nSup>], [<nIzq>], [<nInf>], [<nDer>]) --> cPantalla

 Argumentos

     <nSup>, <nIzq>, <nInf>, y <nDer> definen las coordenadas
     de la parte de la pantalla que va a guardarse. Si <nInf> o <nDer> son
     mayores que MAXROW() o MAXCOL(), la pantalla se recorta. Si no
     especifican coordenadas, se guarda toda la pantalla (es decir, desde 0,0
     hasta MAXROW(), MAXCOL()).

 Devuelve

     SAVESCREEN() devuelve la zona especificada de la pantalla, como cadena
     de carácteres.

 Descripción

     SAVESCREEN() es una función de pantalla que guarda una zona de la
     pantalla en una variable de cualquier clase de almacenamiento,
     incluyendo variables de campo. M.s adelante, puede volver a mostrar la
     imagen de pantalla guardada, en la misma posición o en otra nueva,
     utilizando RESTSCREEN( ). Normalmente, las zonas de pantalla se
     alamacenan y recuperan cuando se utiliza una rutina de men. desplegable
     o se arrastra un objeto de pantalla.

     Advertencia  SAVE SCREEN, RESTORE SCREEN, SAVESCREEN(), y
     RESTSCREEN() se admiten cuando se utiliza el controlador de pantalla por
     defecto. Es posible que otros controladores de pantalla no admitan las
     operación.s de archivo y recuperaci.n de pantallas.

 Ejemplos

     .  La siguiente función definida por el usuario crea un men. que
        aparece en pantalla utilizando ACHOICE() con SAVESCREEN(),
        devolviendo la selecci.n en la matriz de opciónes:

        FUNCTION Menu( nSup, nIzq, nInf, nDer, ;
                             aElementos, cColor )
           LOCAL cPantalla, nOpcion, cUltColor := ;
                 SETCOLOR(cColor)
           //
           cPantalla:= SAVESCREEN(nSup, nIzq, nInf, nDer)
           @ nSup, nIzq TO nInf, nDer DOUBLE
           //
           nOpcion:= ACHOICE(++nSup, ++nIzq, ;
                        --nInf, --nDer, aElementos)
           //
           RESTSCREEN(--nSup, --nIzq, ++nInf, ++nDer, ;
                          cPantalla)
           SETCOLOR(cUltColor)
           RETURN nOpcion

 Ficheros: La biblioteca asociada es EXTEND.LIB.

SCROLL()
 Desplaza una zona de la pantalla hacia arriba o hacia abajo, a la derecha o a
 la izquierda
------------------------------------------------------------------------------
 Sintaxis

     SCROLL([<nSup>], [<nIzq>],[<nInf>],[<nDer>],
            [<nVert>] [<nHoriz>]) --> NIL

 Argumentos

     <nSup>, <nIzq>, <nInf>, y <nDer> definen las coordenadas
     de la zona de desplazamiento. Los valores de filas y columnas pueden ir
     desde 0, 0 hasta MAXROW(), MAXCOL(). Si no especifica argumentos de
     coordenadas, se utilizan las dimensiónes de la pantalla visible.

     <nVert> define el número de filas de desplazamiento vertical. Un
     valor positivo desplaza hacia arriba la pantalla el número especificado
     de filas. Un valor negativo desplaza hacia abajo la pantalla el número
     especificado de filas. Un valor cero desactiva el desplazamiento
     vertical. Si no se especifica <nVert> se asume un valor cero.

     <nHoriz> define el número de filas de desplazamiento horizontal. Un
     valor positivo hace que la pantalla se desplace hacia la izquierda el
     número de columnas especificado. Un valor negativo hace que la pantalla
     se desplace hacia la derecha el número de columnas especificado. Un
     valor cero desactiva el desplazamiento horizontal. Si no se especifica
     <nHoriz>, se asume un valor cero.

     Si no introduce los parámetros <nVert> ni <nHoriz> en SCROLL(), el .rea
     especificada por los cuatro primero parámetros queda en blanco.

     .Advertencia!  El desplazamiento horizontal no se puede utilizar en
     ningúno de los controladores de terminal alternativos (ANSITERM,
     NOVTERM, PCBIOS).

 Devuelve

     SCROLL() siempre devuelve NIL.

 Descripción

     SCROLL() es una función de pantalla que desplaza una zona de .sta hacia
     arriba o hacia abajo un número especificado de filas. Cuando una
     pantalla se desplaza hacia arriba, la primera línea de la zona se borra;
     las líneas restántes se desplazan hacia arriba y se muestra una línea en
     blanco en el color estándar actual en la .ltima línea de la zona
     especificada. Si la zona se desplaza hacia abajo, la operación.se
     invierte. Si la zona de pantalla se desplaza m.s de una línea, se repite
     este proceso.

     SCROLL() se utiliza principalmente para mostrar información de estado en
     una zona definida de la pantalla. Cada vez que se muestra un mensaje
     nuevo, la zona de la pantalla se desplaza una línea hacia arriba y se
     muestra una nueva línea en la parte inferior.

 Ejemplos

     .  Esta función definida por el usuario muestra una cadena de
        mensaje al final de una zona de pantalla después de desplazarla una
        línea hacia arriba:

        FUNCTION DespArr( nSup, nIzq, nInf, nDer, ;
                             expVisual )
           //
           SCROLL(nSup, nIzq, nInf, nDer, 1)
           @ nInf, nIzq SAY expVisual
           //
           RETURN NIL

 Ficheros: La biblioteca asociada es CLIPPER.LIB.

SECONDS()
 Devuelve el número de segundos transcurridos desde la medianoche
------------------------------------------------------------------------------
 Sintaxis

     SECONDS() --> nSegundos

 Devuelve

     SECONDS() devuelve la hora del sistema como valor numérico en forma de
     segundos.cent.simas. El valor numérico devuelto es el número de segundos
     transcurridos desde medianoche y se basa en un reloj de veinticuatro
     horas con un rango de cero a 86399.

 Descripción

     SECONDS() es una función de tiempo que ofrece un m.todo simple para
     calcular el tiempo transcurrido durante la ejecución de un programa
     bas.ndose en el reloj del sistema. Esta función está relacionada con la
     función TIME() que devuelve la hora del sistema como una cadena con el
     formato hh:mm:ss.

 Ejemplos

     .  Este ejemplo contrasta el valor de TIME() con SECONDS():

        ? TIME()               // Resultado: 10:00:00
        ? SECONDS()            // Resultado: 36000.00

     .  Este ejemplo utiliza SECONDS() para controlar el tiempo
        transcurrido en segundos:

        LOCAL nInicio, nTranscurrido
        nInicio:= SECONDS()
        .
        . <sentencias>
        .
        nTranscurrido:= SECONDS() - nInicio
        ? "Transcurrido: " + LTRIM(STR(nTranscurrido)) + " segundos"

 Ficheros:  La biblioteca asociada es CLIPPER.LIB.


SELECT()
 Determina el número de área de trabajo de un alias especificado
------------------------------------------------------------------------------
 Sintaxis

     SELECT([<cAlias>]) --> nAreadeTrabajo

 Argumentos

     <cAlias> es el nombre alias del área de trabajo destáno.

 Devuelve

     SELECT() devuelve el área de trabajo del alias especificado como valor
     numérico entero.

 Descripción

     SELECT() es una función de base de datos que determina el número de .rea
     de trabajo de un alias. El número devuelto puede estar comprendido entre
     cero y 250. Si no se especifica <cAlias>, se devuelve el número del .rea
     de trabajo actual. Si se especifica y el alias no existe, SELECT()
     devuelve cero.

     Nota:  La función SELECT() y el mandato SELECT especificados con un
     argumento de expresión ampliado tienen un aspecto muy similar. Esto no
     debe constituir un problema ya que la función SELECT() no es muy .til en
     s. misma si figura aislada en una línea.

 Ejemplos

     .  Este ejemplo utiliza SELECT() para determinar qu. .rea de
        trabajo ha seleccionado USE...NEW:

        USE Ventas NEW
        SELECT 1
        ? SELECT("Ventas")            // Resultado: 4

     .  Para volver a seleccionar el valor devuelto por la función
        SELECT(), utilice el mandato SELECT con la sintaxis
        SELECT(<idVarmem>), del modo siguiente:

        USE Ventas NEW
        nAreadeTrabajo:= SELECT()
        USE Cliente NEW
        SELECT (nAreadeTrabajo)

 Ficheros:  La biblioteca asociada es CLIPPER.LIB.

SET()
 Comprueba o modifica un valor de configuración del sistema
------------------------------------------------------------------------------
 Sintaxis

     SET(<nEspecificador>, [<expNuevoValor>],
         [<lModoApertura>]) --> ValorActual

 Argumentos

          <nEspecificador> es un valor numérico que identifica al valor que
          debe comprobarse o modificarse. <nEspecificador> debe proporcionarse
          como una constante declarada (ver a continúa.ión).
          <expNuevoAjuste> es un argumento opciónal que indica un valor
          nuevo para <nEspecificador>. El tipo de este argumento depende de
          <nEspecificador>.
          <lModoApertura> es un valor l.gico que indica si los ficheros que
          se abren para los siguientes pr.positos:
          _SET_ALTFILE, _SET_PRINTFILE, _SET_EXTRAFILE
          deber.an truncarse o abrirse en modo de adici.n. Un valor de falso
          (.F.) signfica que el fichero debe truncarse. Un valor de verdadero
          significa que el fichero debe abrirse en modo de adici.n. En
          cualquier caso, si el fichero no existe se crea.
          Si no se especifica este argumento, el valor por defecto es modo de
          adici.n.
 Devuelve

          SET() devuelve el valor de configuración actual de la carácter.stica
          especificada.
 Descripción

          SET() es una función del sistema que le permite comprobar o modificar
          los valores de sistema de CA-Clipper. Para obtener más información
          sobre el significado y valores correctos para un ajuste en concreto,
          consulte el mandato o función asociados.
          Use una constante declarada para especificar el ajuste que deba ser
          comprobado o modificado. Estas constantes se definen en un fichero
          de cabecera llamado Set.ch. Este fichero debe incluirse al principio
          de cualquier módulo fuente que utilice SET().
     Set.ch también define una constante llamada _SET _COUNT. Esta constante
     es igual al número de ajustes que pueden cambiarse o inspeccionarse con
     SET(), permitiendo la construcci.n de una función gen.rica que conserva
     todos los ajustes (consulte el ejemplo que aparece m.s adelante).

          Nota:  Los valores numéricos de las constantes declaradas en
          Set.ch dependen de la versi.n y nunca deben utilizarse directamente,
          siempre deben utilizarse las constantes declaradas.
          Si <nEspecificador> o <expNuevoAjuste> no son víaacute;lidos, se ignora la
          llamada a SET().
     Valores de Set Definidos en Set.ch
     ------------------------------------------------------------------------
     Constante           Tipo de Valor        Mandato o función Asociados
     ------------------------------------------------------------------------
     _SET_EXACT          L.gico               SET EXACT
     _SET_FIXED          L.gico               SET FIXED
     _SET_DECIMALS       numérico             SET DECIMALS
     _SET_DATEFORMAT     C.racter             SET DATE
     _SET_EPOCH          numérico             SET EPOCH
     _SET_PATH           C.racter             SET PATH
     _SET_DEFAULT        C.racter             SET DEFAULT
     _SET_EXCLUSIVE      L.gico               SET EXCLUSIVE
     _SET_SOFTSEEK       L.gico               SET SOFTSEEK
     _SET_UNIQUE         L.gico               SET UNIQUE
     _SET_DELETED        L.gico               SET DELETED
     _SET_CANCEL         L.gico               SETCANCEL()
     _SET_DEBUG          L.gico               ALTD()
     _SET_COLOR          C.racter             SETCOLOR()
     _SET_CURSOR         numérico             SETCURSOR()
     _SET_CONSOLE        L.gico               SET CONSOLE
     _SET_ALTERNATE      L.gico               SET ALTERNATE
     _SET_ALTFILE        C.racter             SET ALTERNATE TO
     _SET_DEVICE         C.racter             SET DEVICE
     _SET_PRINTER        L.gico               SET PRINTER
     _SET_PRINTFILE      C.racter             SET PRINTER TO
     _SET_MARGIN         numérico             SET MARGIN
     _SET_BELL           L.gico               SET BELL
     _SET_CONFIRM        L.gico               SET CONFIRM
     _SET_ESCAPE         L.gico               SET ESCAPE
     _SET_INSERT         L.gico               READINSERT()
     _SET_EXIT           L.gico               READEXIT()
     _SET_INTENSITY      L.gico               SET INTENSITY
     _SET_SCOREBOARD     L.gico               SET SCOREBOARD
     _SET_DELIMITERS     L.gico               SET DELIMITERS
     _SET_DELIMCHARS     C.racter             SET DELIMITERS TO
     _SET_WRAP           L.gico               SET WRAP
     _SET_MESSAGE        numérico             SET MESSAGE
     _SET_MCENTER        L.gico               SET MESSAGE
     ------------------------------------------------------------------------

     Nota:  _SET_EXTRAFILE y _SET_SCROLLBREAK no tienen mandatos
     correspondientes. _SET_EXTRAFILE le permite especificar un fichero
     alternativo adicional y _SET_SCROLLBREAK activar o desactivar la
     interpretaci.n de Ctrl-S.

 Ejemplos

     .  Este ejemplo muestra una función definida por el usuario que
        conserva o restaura toda la configuración. Esta función podr.a
        utilizarse al entrar en un subsistema para garantizar que .ste no
        afecta al estado del programa que lo ha llamado:

        #include "Set.ch"
        //

        FUNCTION EstablecerTodo( aNuevosValores )
           LOCAL aValoresActuales[_SET_COUNT], nActuales
           IF ( aNuevosValores != NIL )   // Establecer los nuevos y  devolver los
        actuales
              FOR nActuales := 1 TO _SET_COUNT
                 aValoresActuales[nActuales] := ;
                    SET(nActuales, aNuevosValores[nActuales])
              NEXT
           ELSE         // Devolver sólo actuales
              FOR nActuales := 1 TO _SET_COUNT
                 aValoresActuales[nActuales] := SET(nActuales)
              NEXT
           ENDIF
           RETURN (aValoresActuales)

 Ficheros:  La biblioteca asociada es CLIPPER.LIB
            y el fichero de cabecera Set.ch.

SETBLINK()
 Activa o desactiva la interpretaci.n del asterisco (*) en la cadena
 SETCOLOR() entre parpadeo e intensidad de fondo
------------------------------------------------------------------------------
 Sintaxis

     SETBLINK([<lActivar/Desactivar>]) --> lValorActual

 Argumentos

     <lActivar/Desactivar> modifica el significado del carácter asterisco
     (*) cuando se encuentra en una cadena SETCOLOR(). Especificando
     verdadero, se establece el parpadeo de los carácteres; falso (.F.)
     establece la intensidad del fondo. El valor por defecto es verdadero
     (.T.).

 Devuelve

     SETBLINK() devuelve el valor de la configuración actual como valor
     l.gico.

 Descripción

     SETBLINK() es una función de entorno que activa o desactiva el atributo
     de parpadeo/intensidad de fondo e informa sobre el estado actual de
     SETBLINK(). Cuando la función est. activada, los carácteres escritos en
     la pantalla parpadean mediante la inclusi.n de un asterisco (*) en una
     cadena de color pasada a SETCOLOR(). Cuando SETBLINK() est. desactivado,
     el asterisco hace que el color del fondo se intensifique. As. pues, los
     atributos de parpadeo e intensidad de fondo no están disponibles a la
     vez.

     Nota:  Esta función sólo tiene sentido en PCs de IBM u ordenadores
     compatibles con dispositivos de visualización CGA, EGA, o VGA.

 Ejemplos

     .  Este ejemplo guarda el estado actual SETBLINK() antes de pasar
        el control a una función definida por el usuario. Tras la devoluci.n
        SETBLINK() se restaura a su valor original:

        lParpAnti := SETBLINK()
        MiFunc()
        SETBLINK(lParpAnti)

 Ficheros:  La biblioteca asociada es CLIPPER.LIB.


SETCANCEL()
 Activa o desactiva Alt-C y Ctrl-Intro como teclas de finalizaci.n de programa
------------------------------------------------------------------------------
 Sintaxis

     SETCANCEL([<lActivar/Desactivar>]) --> lAjusteActual

 Argumentos

     <lActivar/Desactivar> modifica la disponibilidad de Alt-C y
     Ctrl-Intro como teclas de finalizaci.n. Un valor de verdadero (.T.)
     permite la utilización de ambas combinaciónes de teclas para finalizar
     una aplicación y un valor de falso (.F.) las desactiva. El valor por
     defecto es verdadero (.T.).

 Devuelve

     SETCANCEL() devuelve el ajuste actual como valor l.gico.

 Descripción

     SETCANCEL() es una función de teclado que activa o desactiva el estado
     de las teclas de finalizaci.n Alt-C y Ctrl-Inter, e informa sobre el
     estado actual de SETCANCEL().

     Tenga en cuenta que si Alt-C o Ctrl-Enter se redefinen con SET KEY, esta
     nueva definición tiene precedencia aunque SETCANCEL() devuelva verdadero
     (.T.).

     .Advertencia!  Cuando se establece SETCANCEL() como falso (.F.), el
     usuario no puede finalizar un programa fuera de control a menos que se
     le proporcione un mecanismo de escape alternativo.

 Ejemplos

     .  Este ejemplo ofrece una vía de escape a partir de un estado de
        espera con la función SET CANCEL() desactivada:

        #define K_ALTC   302
        //
        SETCANCEL(.F.)               // Desactivar teclas de finalizaci.n
        SET KEY K_ALTC TO AltC       // Redefinir Alt-C
        .
        . <sentencias>
        .
        RETURN
        FUNCTION AltC
           LOCAL cPantalla, nOpcion, cúltimoColor := ;
                 SETCOLOR("W/B, N/G")
           //
           SAVE SCREEN TO cPantalla
           @ 6, 20 CLEAR TO 9, 58
           @ 6, 20 TO 9, 58 DOUBLE
           @ 7, 26 SAY "Alt-C: .Desea salir?"
           @ 8, 35 PROMPT " S. "
           @ 8, 41 PROMPT " No "
           MENU TO nOpcion
           SETCOLOR(cúltimoColor)
           RESTORE SCREEN FROM cPantalla
           //
           IF nOpcion = 1
              QUIT
           ENDIF
           //
           RETURN NIL

 Ficheros: La biblioteca asociada es CLIPPER.LIB.


SETCOLOR()
Devuelve los colores actuales y, opciónalmente, establece algunos nuevos
------------------------------------------------------------------------------

Sintaxis

     SETCOLOR([<cCadenaColor>])  cCadenaColor

Argumentos

     <cCadenaColor> es una cadena de carácteres que contiene una lista
     de atributos de color para la posterior salida por pantalla. La
     siguiente es una lista de ajustes y ámbitos relacionados:

     configuraciónes de Color
     ------------------------------------------------------------------------
     configuración      ámbito
     ------------------------------------------------------------------------
     Est.ndar           Todosólos mandatos y funciónes de salida por pantalla
     Resaltado          GET y zonas resaltadas de opciónes
     Borde              Borde alrededor de la pantalla; no se usa en EGA y VGA
     Fondo              No est. admitido
     Sin Selec.         GET sin seleccionar u opción de men. no accesible
     ------------------------------------------------------------------------

     Cada configuración es un par de colores de primer plano y fondo
     separados por un carácter de barra (/) y seguidos por una coma. Todas
     las configuraciónes son opciónales. Si se ignora una configuración,
     se conserva su valor previo estableci.ndose sólo valores nuevos.

Devuelve

     SETCOLOR() devuelve el ajuste de color actual como una cadena de
     carácteres.

Descripción

     SETCOLOR() es una función de pantalla que guarda la configuración de
     color actual o establece nuevos colores para el posterior coloreado
     de la pantalla. Una cadena de color est. formada por varias
     configuraciónes de color, correspondiendo cada color a diferentes
     zonas de la pantalla. Tal y como se ha dicho anteriormente, cada
     configuración consta de un color de primer plano y otro de fondo. El
     primer plano define el color de los carácteres que se muestran en la
     pantalla. El fondo define el color que se muestra detrás del
     carácter. Los espacios y carácteres que no se visualización se
     muestran como fondo.
     En CA-Clipper, las configuraciónes que definen el comportamiento de
     los colores son:

     Est.ndar: La configuración estándar controla todos los mandatos y
     funciónes de consola, pantalla completa e interfaz cuando se muestran
     en la pantalla. Esto incluye mandatos como @...PROMPT, @...SAY y ? y
     funciónes como ACHOICE(), DBEDIT() y MEMOEDIT().

     Resaltado: La configuración resaltada controla la visualización
     de las zonas resaltadas. Esto incluye GET si se ha establecido SET
     INTENSITY ON y las zonas resaltadas de selecci.n de MENU TO, DBEDIT()
     y ACHOICE().

     Borde: El borde es un .rea situada alrededor de la pantalla en la
      cual no puede escribirse.

     Fondo: El fondo no se utiliza.

     Sin selecionar: Esta configuración se usa para visualizar los GET
     no seleccionados y las opciónes de men. no disponibles.  Además de los
     colores, los ajustes de primer plano pueden tener atributos de
     intensidad alta y/o parpadeo. Con una pantalla monocroma, la intensidad
     alta aumenta el brillo del texto. Con una pantalla en color, la
     intensidad cambia la tonalidad del color especificado. Por ejemplo, "N"
     muestra el texto de primer plano en negro mientras que "N+" lo muestra
     en gris. La intensidad alta viene indicada mediante "+". El atributo de
     parpadeo hace que el texto de primer plano aparezca y desaparezca a
     intervalos r.pidos. Este atributo se indica mediante "*". El carácter
     de atributo puede estar en cualquier punto de la cadena de configuración,
     pero siempre afecta al color de primer plano con independencia del lugar
     en que se introduzca.

     Se admiten los siguientes colores:

     Lista de Colores
     ------------------------------------------------------------------------
     Color           Letra           Monocromo
     ------------------------------------------------------------------------
     Negro           N, Espacio      Negro
     Azul            B               Subrayado
     Verde           G               Blanco
     Cian            BG              Blanco
     Rojo            R               Blanco
     Magenta         RB              Blanco
     Marr.n          GR              Blanco
     Blanco          W               Blanco
     Gris            N+              Blanco
     Azul Intenso    B+              Subr. Intenso
     Verde Intenso   G+              Blanco Intenso
     Cian Intenso    BG+             Blanco Intenso
     Rojo Intenso    R+              Blanco Intenso
     Magenta Int.    RB+             Blanco Intenso
     Amarillo        GR+             Blanco Intenso
     Blanco Intenso  W+              Blanco Intenso
     Negro           U               Subrayado
     V.deo Inverso   I               V.deo Inverso
     En Blanco       X               En Blanco
     ------------------------------------------------------------------------

 Notas

     .  Argumentos no especificados: Al contrario que SET COLOR
        TO, SETCOLOR() sin argumentos no restaura los colores a sus valores
        por defecto.

     .  números de colores: SETCOLOR() admite combinaciónes de
        letras de colores pero no de números de colores.

 Ejemplos

     .  Este ejemplo asigna la configuración de color actual a la
        variable cColor:

        cColor:= SETCOLOR()

     .  Este ejemplo utiliza SETCOLOR() para guardar la configuración
        de color actual y establecer una nueva.

        cColorNuevo:= "BR+/N, R+/N"
        cColorAntiguo:= SETCOLOR(cColorNuevo)

     .  Este ejemplo utiliza SET COLOR TO para volver a establecer los
        colores por defecto:

        SET COLOR TO
        ? SETCOLOR()            // Resultado: W/N, N/W, N, N, N/W

     .  Estos dos ejemplos especifican SETCOLOR() sin algunas
        configuraciónes:

        // configuraciónes omitidas
        SETCOLOR("W/N, BG+/B")
        //
        // configuraciónes ignoradas dentro de la lista
        SETCOLOR("W/N, BG+/B,,,W/N")

     .  Este ejemplo utiliza SETCOLOR() con ISCOLOR() para establecer
        los colores, dependiendo del tipo de pantalla:

        FUNCTION ColoresDefecto
           IF ISCOLOR()
              cFormulario := "W+/N, BG+/B,,,W/N"
              cDialogo := "N/N+, BG+/B,,,N/N+"
              cAviso := "W+/R, BG+/B,,,W+/R"
           ELSE
              cFormulario := "W+/N, N/W,,,W/N"
              cDialogo := "W+/N, N/W,,,W/N"
              cAviso := "W+/N, N/W,,,W/N"
           ENDIF
           RETURN NIL

 Ficheros: La biblioteca asociada es CLIPPER.LIB.

SETCURSOR()
 Establece la forma del cursor
------------------------------------------------------------------------------
 Sintaxis

     SETCURSOR([<nFormaCursor>]) --> nFormaActual

 Argumentos

     <nFormaCursor> es un número que indica la forma del cursor. Para
     códigos sencillos, el fichero de cabecera Setcurs.ch ofrece nombres
     descriptivos para las diversas formas del cursor tal y como se muestra
     en la siguiente tabla:

     Formas del Cursor
     ------------------------------------------------------------------------
     Formas                   Valor    Setcurs.ch
     ------------------------------------------------------------------------
     Ninguna                  0        SC_NONE
     Subrayado                1        SC_NORMAL
     Bloque medio inferior    2        SC_INSERT
     Bloque completo          3        SC_SPECIAL1
     Bloque medio superior    4        SC_SPECIAL2
     ------------------------------------------------------------------------

 Devuelve

     SETCURSOR() devuelve la forma actual del cursor como valor numérico.

 Descripción

     SETCURSOR() es una función de entorno que controla la forma del cursor
     de pantalla. La forma real depende del controlador actual de la
     pantalla. Las formas especificadas aparecen en PC de IBM y ordenadores
     compatibles. En otros ordenadores, el aspecto puede diferir para cada
     valor especificado.

     SETCURSOR(0) equivale a SET CURSOR OFF y cualquier valor entero positivo
     de <nFormaCursor> menor que 5 equivale a SET CURSOR ON. El cursor se
     muestra con la forma seleccionada.

 Ejemplos

     .  Este ejemplo utiliza SETCURSOR() para que el cursor adopte la
        forma de bloque completo para el READ posterior. Una vez finalizado
        el READ, SETCURSOR() desactiva el cursor:

        #include "Setcurs.ch"
        //
        USE Cliente NEW
        @ 10, 10 GET Cliente->Nombre
        @ 11, 10 GET Cliente->Telefono
        //
        SETCURSOR(SC_SPECIAL1)         // Cambiar el cursor a bloque
        READ
        SETCURSOR(SC_NONE)             // Desactivar cursor

 Ficheros: La biblioteca asociada es CLIPPER.LIB
            y el fichero de cabecera Setcurs.ch.

SETKEY()
 Asigna un bloque de acci.n a una tecla
------------------------------------------------------------------------------
 Sintaxis

     SETKEY(<nC.digoInkey>, [<bAcción>]) --> bAcciónActual

 Argumentos

     <nC.digoInkey> es el valor INKEY() de la tecla a la que va a
     asociarse la acci.n o que va a consultarse.

     <bAcción> especifica un bloque de código que se ejecuta
     autom.ticamente siempre que se pulsa la tecla especificada durante un
     estado de espera.

 Devuelve

     SETKEY() devuelve el bloque de acci.n asociado actualmente a la tecla
     especificada o NIL si dicha tecla no est. asociada a ningún bloque.

 Descripción

     SETKEY() es una función de teclado que establece o consulta la acci.n
     autom.tica asociada a una tecla determinada durante un estado de espera.
     Un estado de espera es cualquier modo que lee del teclado a excepci.n de
     INKEY(), pero incluyendo ACHOICE(), DBEDIT(), MEMOEDIT(), ACCEPT, INPUT,
     READ y WAIT. Pueden asignarse hasta 32 teclas a la vez. Al arrancar, el
     sistema asigna autom.ticamente la tecla F1 para ejecutar u procedimiento
     o función definida por el usuario denominado Help.

     Cuando se pulsa una tecla asignada durante un estado de espera, la
     función EVAL() eval.a la <bAcción> asociada y los parámetros PROCNAME(),
     PROCLINE() y READVAR(). Sin embargo, no es necesario listar los
     argumentos al especificar <bAcción> si no se van a utilizar dentro del
     bloque de acci.n.

     SETKEY() es como el mandato SET KEY que asocia una llamada a un
     procedimiento a una tecla.

 Ejemplos

     .  Este fragmento de código asocia un bloque de acci.n a una
        tecla, después, tras obtener una tecla con INKEY(), la ejecuta con la
        función EVAL():

        #include "Inkey.ch"
        SETKEY(K_DN, {|cProc, nLinea, cVar| MiProc(cProc, ;
                          nLinea, cVar)})
        .
        . <sentencias>
        .
        DO WHILE .T.
           nTecla := INKEY(0)
           DO CASE
           CASE (bAcción := SETKEY(nTecla)) != NIL
              EVAL(bAcción, PROCNAME(), PROCLINE(), READVAR())
           CASE nTecla = K_PGUP
              Previous()
           CASE nTecla = K_PGDN
              Next()
           CASE nTecla = K_ESC
              EXIT
           ENDCASE
        ENDDO

 Ficheros:  La biblioteca asociada es CLIPPER.LIB
            y el fichero de cabecera Inkey.ch.


SETMODE()
 Cambia el modo de visualización a un número especificado de filas y columnas
------------------------------------------------------------------------------
 Sintaxis

     SETMODE(<nFilas>, <nCols>) --> lCorrecto

 Argumentos

     <nFilas> es el número de filas en el modo de visualización deseado.

     <nCols> es el número de columnas en el modo de visualización
     deseado.

 Devuelve

     SETMODE() devuelve verdadero (.T.) si el cambio de modo ha sido
     satisfactorio; en caso contrario, devuelve falso (.F.).

 Descripción

     SETMODE() es una función de entorno que intenta cambiar el modo del
     dispositivo de visualización para que coincida con el número de filas y
     columnas especificado. El cambio en el tama.o de la pantalla se refleja
     en los valores devueltos por MAXROW() y MAXCOL().

 Ejemplos

     .  Este ejemplo cambia a un modo de visualización de 43 líneas:

        IF SETMODE(43, 80)
           ? "modo de 43 líneas establecido con .xito"
        ELSE
           ? "modo de 43 líneas no disponible"
        ENDIF

 Ficheros:  La biblioteca asociada es CLIPPER.LIB.

SETPOS()
 Desplaza el cursor a una nueva posición
------------------------------------------------------------------------------
 Sintaxis

     SETPOS(<nFila>, <nCol>) --> NIL

 Argumentos

     <nFila> y <nCol> definen la nueva posición de pantalla del
     cursor. Estos valores pueden estar comprendidos entre 0,0 y MAXROW(),
     MAXCOL().

 Devuelve

     SETPOS() siempre devuelve NIL.

 Descripción

     SETPOS() es una función de entorno que desplaza el cursor a una nueva
     posición en la pantalla. Una vez situado el cursor, ROW() y COL() se
     actualizan en consecuencia. Para controlar la forma y visibilidad del
     cursor, utilice la función SETCURSOR().

 Ejemplos

     .  Este ejemplo desplaza el cursor a una nueva posición, después
        muestra una cadena en la pantalla utilizando un mandato de consola,
        ??:

        SETPOS(1, 1)
        ?? "Hola a todos"

 Ficheros:  La biblioteca asociada es CLIPPER.LIB.

SETPRC()
 Establece los valores PROW() y PCOL()
------------------------------------------------------------------------------
 Sintaxis

     SETPRC(<nFila>, <nCol>) --> NIL

 Argumentos

     <nFila> es el nuevo valor de PROW().

     <nCol> es el nuevo valor de PCOL().

 Devuelve

     SETPRC() siempre devuelve NIL.

 Descripción

     SETPRC() es una función de impresora que envía códigos de control a la
     impresora sin cambiar la posición de la cabeza de impresión. Cuando CA-
     Clipper imprime, actualiza el valor de PCOL() con el número de
     carácteres envíado a la impresora. No existe diferencia entre carácteres
     que pueden imprimirse y aqu.llos que no pueden hacerlo. Si, por ejemplo,
     se envía a la impresora una cadena de diez carácteres que contiene dos
     carácteres interpretados como código de control por la impresora, el
     valor de PCOL() de CA-Clipper se incrementa en diez mientras que la
     posición real de la cabeza de impresión sólo se desplaza ocho. Esto
     puede llevar a problemas de alíneaci.n. Mediante el uso de SETPRC()
     puede compensar estos códigos de control volviendo a establecer PCOL()
     tal y como se muestra en el ejemplo que aparece m.s adelante.

     SETPRC() también suprime los saltos de p.gina al imprimir con @...SAY.
     Esto es importante cuando la siguiente posición de fila es menor que la
     fila actual y no se ha ejecutado un EJECT. En esta situaci.n, CA-Clipper
     ejecuta un salto de p.gina autom.tico si la siguiente posición de
     impresi.n de fila es menor que el valor actual de PROW(). Con SETPRC(),
     puede establecer PROW() a un número inferior a la fila actual,
     eliminando as. el EJECT autom.tico.

 Ejemplos

     .  Esta función definida por el usuario, ImprimirCodigos(),
        utiliza SETPRC() para envíar códigos de control a la impresora sin
        afectar a los valores de PROW() y PCOL():

           #include "Set.ch"
           #define ITALICS_ON CHR(27) + "I"
           #define ITALICS_OFFCHR(27) + "E"
           //
           SET DEVICE TO PRINTER
           @ 12, 10 SAY "Se trata de una"
           @ PROW(), PCOL() + 2 SAY ImprimirCodigos(ITALICS_ON) + ;
                 "importante"
           @ PROW(), PCOL() + 2 SAY ImprimirCodigos(ITALICS_OFF) + ;
                 "reuni.n"
           SET DEVICE TO SCREEN
           RETURN

           FUNCTION ImprimirCodigos( cCodigoCtrl )
             LOCAL nFila, nCol, lImpresora
             lImpresora := SET(_SET_PRINTER, .T.)  // SET PRINTER ON
             nFila:= PROW()                        // Guardar posición cabeza
                                                   // de impresión
             nCol:= PCOL()
             //
             ?? cCodigoCtrl                        // Envíar código de control
             //
             SETPRC(nFila, nCol)
             SET(_SET_PRINTER, lImpresora)         // Recuperar parámetros
                                                   // de impresora
             RETURN ""                             // Devolver una cadena nula

 Ficheros:   La biblioteca asociada es CLIPPER.LIB.

SOUNDEX()
 Convierte una cadena de carácteres en su cadena de similitud fon.tica
------------------------------------------------------------------------------
 Sintaxis

     SOUNDEX(<cCadena>) --> cCadenaSimilFon

 Argumentos

     <cCadena> es la cadena de carácteres que debe convertirse.

 Devuelve

     SOUNDEX() devuelve una cadena de carácteres de cuatro dígitos en la
     forma A999.

 Descripción

     SOUNDEX() es una función de carácteres que indexa y busca coincidencias
     fon.ticas o sonidos similares. Se utiliza en aplicaciónes en las que no
     se conoce la ortograf.a precisa de las claves de carácteres o en las que
     existe una probabilidad alta de nombres mal escritos. Los errores
     ortogr.ficos son muy normales en sistemas de transacci.n en tiempo real
     en los que el operador de entrada de datos recibe la información a
     trav.s del tel.fono. SOUNDEX() funcióna reuniendo los sonidos semejantes
     bajo el mismo valor clave. Sin embargo, tenga en cuenta que el m.todo de
     similitud fon.tica no es absoluto. Claves que son bastante diferentes
     pueden dar como resultado el mismo valor de similitud fon.tica.

 Ejemplos

     .  Este ejemplo genera un ííndice utilizando SOUNDEX() para crear
        los valores claves. Despu.s, busca un valor encontrado en el campo
        Vendedor:

        USE Ventas
        INDEX ON SOUNDEX(Vendedor) TO Vendedor
        SEEK SOUNDEX("Pedrol")
        ? FOUND(), Vendedor            // Resultado: .T. Pedrol

     .  Aqu., se busca la misma clave que en el ejemplo anterior pero
        con una ortograf.a diferente:

        SEEK SOUNDEX("Pedroll")
        ? FOUND(), Vendedor            // Resultado: .T. Pedrol

 Ficheros:  La biblioteca asociada es EXTEND.LIB
            y el fichero fuente SOURCE\SAMPLE\SOUNDEX.C

SPACE()
 Devuelve una cadena de espacios
------------------------------------------------------------------------------
 Sintaxis

     SPACE(<nEspacios>) --> cEspacios

 Argumentos

     <nEspacios> es el número de espacios que va a devolverse hasta un
     máximo de 65.535 (64K).

 Devuelve

     SPACE() devuelve una cadena de carácteres. Si <nEspacios> es cero,
     SPACE() devuelve una cadena nula ("").

 Descripción

     SPACE() es una función de carácteres que devuelve un número especificado
     de espacios. Equivale a REPLICATE(" ", <nVeces>). SPACE() puede
     inicializar una variable de carácteres antes de asociarla a un GET.
     SPACE() puede también rellenar cadenas con espacios iniciales o finales.
     Sin embargo, tenga en cuenta que para este prop.sito son m.s eficaces
     las funciónes PAD(), PADL() y PADR().

 Ejemplos

     .  Este ejemplo utiliza SPACE() para inicializar una variable
        para entrada de datos:

        USE Cliente NEW
        MEMVAR->Nombre = SPACE(LEN(Cliente->Nombre))
        @ 10,10 SAY "Nombre Cliente" GET MEMVAR->Nombre
        READ

 Ficheros:  La biblioteca asociada es CLIPPER.LIB.


SQRT()
 Devuelve la ra.z cuadrada de un número positivo
------------------------------------------------------------------------------
 Sintaxis

     SQRT(<nNúmero>) --> nRa.z

 Argumentos

     <nNúmero> es un número positivo del cual va a extraerse la ra.z
     cuadrada.

 Devuelve

     SQRT() devuelve un valor numérico calculado con doble precisión. El
     número de lugares decimales mostrado se determina mediante SET DECIMALS
     sin tener en cuenta SET FIXED. Si <nNúmero> es negativo, SQRT devuelve
     cero.

 Descripción

     SQRT() es una función numérica utilizada en cualquier parte de un
     c.lculo numérico para hallar una ra.z cuadrada (por ejemplo, en una
     expresión que calcule la desvíaci.n estándar).

 Ejemplos

     .  Estos ejemplos muestran varios resultados de SQRT():

        SET DECIMALS TO 5
        //
        ? SQRT(2)                  // Resultado: 1,41421
        ? SQRT(4)                  // Resultado: 2,00000
        ? SQRT(4) ** 2             // Resultado: 4,00000
        ? SQRT(2) ** 2             // Resultado: 2,00000

 Ficheros:  La biblioteca asociada es CLIPPER.LIB.

STR()
 Convierte una expresión numérica en una cadena de carácteres
------------------------------------------------------------------------------
 Sintaxis

     STR(<nNúmero>, [<nLongitud>], [<nDecimales>]) --> cnúmero

 Argumentos

     <nNúmero> es la expresión numérica que va a convertirse en una
     cadena de carácteres.

     <nLongitud> es la longitud de la cadena de carácteres que debe
     devolverse, incluyendo dígitos decimales, coma decimal y signo.

     <nDecimales> es el número de posiciónes decimales que hay que
     devolver.

 Devuelve

     STR() devuelve <nNúmero> con formato de cadena de carácteres. Si no se
     especifican los argumentos opciónales de longitud y decimales, STR()
     devuelve la cadena de carácteres de acuerdo con las siguientes reglas:

     Resultados de STR() sin Argumentos Opcionales
     ------------------------------------------------------------------------
     Expresi.n            Longitud de Retorno
     ------------------------------------------------------------------------
     Variable de campo    Longitud del campo m.s decimales
     Expr./constantes     M.nimo de 10 dígitos m.s decimales
     VAL()                M.nimo de 3 dígitos
     MONTH()/DAY()        3 dígitos
     YEAR()               5 dígitos
     RECNO()              7 dígitos
     ------------------------------------------------------------------------

 Descripción

     STR() es una función de conversión numérica que convierte valores
     numéricos en cadenas de carácteres. Se utiliza con frecuencia para
     concatenar valores numéricos a cadenas de carácteres. STR() tiene
     aplicaciónes mostrando números, creando códigos a partir de valores
     numéricos como, por ejemplo, números de referencia y creando claves de
     índice que combinan datos numéricos y de tipo carácter.

     STR() es similar a TRANSFORM(), que da formato a valores numéricos como
     cadenas de carácteres útilizando una m.scara en lugar de
     especificaciónes de longitud y decimales.

     La función inversa de STR() es VAL() que convierte valores de tipo
     carácter en números.

 Notas

     .  Si <nLongitud> es menor que el número de dígitos de número
        entero de <nNúmero>, STR() devuelve asteriscos en vez del número.

     .  Si <nLongitud> es menor que el número de dígitos decimales
        necesarios para la parte decimal de la cadena de retorno, CA-Clipper
        redondea el número al número disponible de posiciónes decimales.

     .  Si se especifica <nLongitud>, pero se omite <nDecimales> (sin
        lugares decimales), el valor de retorno se redondea a un entero.

 Ejemplos

     .  Estos ejemplos demuestran el rango de valores devueltos por
        STR(), dependiendo de los argumentos especificados:

        nNúmero:= 123.45
        ? STR(nNúmero)                     // Resultado: 123.45
        ? STR(nNúmero, 4)                  // Resultado: 123
        ? STR(nNúmero, 2)                  // Resultado: **
        ? STR(nNúmero * 10, 7, 2)          // Resultado: 1234.50
        ? STR(nNúmero * 10, 12, 4)         // Resultado: 1234.5000
        ? STR(nNúmero, 10, 1)              // Resultado: 1234.5

     .  Este ejemplo utiliza STR() para crear un ííndice con una clave
        compuesta de números de pedido y nombres de cliente:

        USE Cliente NEW
        INDEX ON STR(NumPedido, 9) + NomClien TO PedClien

 Ficheros:  La biblioteca asociada es CLIPPER.LIB.

STRTRAN()
 Busca y sustituye carácteres dentro de una cadena de carácteres o campo memo
------------------------------------------------------------------------------
 Sintaxis

     STRTRAN(<cCadena>, <cB.squeda>, [<cSustituir>], [<nInicio>],
             [<nNúmero>]) --> cNuevaCadena

 Argumentos

     <cCadena> es la cadena de carácteres o campo memo en los que debe
     realizarse la b.squeda.

     <cB.squeda> es la secuencia de carácteres que hay que encontrar.

     <cSustituir> es la secuencia de carácteres que va a sustituir a
     <cB.squeda>. Si no se especifica este argumento,  las apariciones
     especificadas del argumento de b.squeda se sustituyen por una cadena
     vac.a ("").

     <nInicio> es la primera aparici.n que debe sustituirse. Si se ignora
     este argumento, el valor por defecto es uno.

     <nNúmero> es el número de apariciones que deben sustituirse. Si no
     se especifica, el valor por defecto es todas.

 Devuelve

     STRTRAN() devuelve una nueva cadena de carácteres con los casos
     especificados de <cB.squeda> reemplazados por <cSustituir>.

 Descripción

     STRTRAN() es una función de carácteres que lleva a cabo la b.squeda
     estándar de una subcadena dentro de una cadena de carácteres. Cuando
     localiza una coincidencia, sustituye la cadena buscada por la cadena de
     sustituci.n especificada. Se sustituyen todas las apariciones de
     <cB.squeda> a menos que se especifique <nInicio> o <nNúmero>. Tenga en
     cuenta que STRTRAN() sustituye subcadenas y, por lo tanto, no tiene en
     cuenta palabras enteras.

 Ejemplos

     .  Este ejemplo utiliza STRTRAN() para establecer un an.logo
        postmoderno a una famosa cita:

        cCadena:= "Calcular o no calcular?"
        ? STRTRAN(cCadena, "calcular", "ser")
        // Resultado:  Ser o no ser?

 Ficheros:  La biblioteca asociada es CLIPPER.LIB.

STUFF()
 Borra e inserta carácteres en una cadena
------------------------------------------------------------------------------
 Sintaxis

     STUFF(<cCadena>, <nInicio>, <nBorrar>, <cInsertar>) --> cNuevaCadena

 Argumentos

     <cCadena> es la cadena de carácteres destáno en la que se insertan y
     borran carácteres.

     <nInicio> es la posición inicial en la que se produce la
     inserci.n/borrado.

     <nBorrar> es el número de carácteres que hay que borrar.

     <cInsertar> es la cadena que debe insertarse.

 Devuelve

     STUFF() devuelve una copia de <cCadena> con los carácteres especificados
     borrados y con <cInsertar> insertada.

 Descripción

     STUFF() es una función de carácteres que borra <nBorrar> carácteres de
     <cCadena> empezando en la posición <nInicio>. A continúa.ión, inserta
     <cInsertar> en la cadena resultante empezando en la posición <nInicio>
     para formar la cadena de retorno. De esta forma, STUFF() puede realizar
     las seis operación.s siguientes:

     .  Insertar: Si <nBorrar> es cero, no se suprimen carácteres
        de <cCadena>. <cInsertar> se inserta en <nInicio> y se devuelve toda
        la cadena. Por ejemplo STUFF("Mi perro tiene pulgas." 16, 0, "no ")
        devuelve "Mi perro no tiene pulgas".

     .  Sustituir: Si <cInsertar> tiene la misma longitud que
        <nBorrar>, <cInsertar> sustituye los carácteres empezando en
        <nInicio> y la cadena resultante tiene la misma longitud que la
        original. Por ejemplo, STUFF("Mi perro tiene pulgas.", 16, 6,
        "huesos") devuelve "Mi perro tiene huesos".

     .  Borrar: Si <cInsertar> es una cadena nula (""), se borra
        de <cCadena> el número de carácteres especificado por <nBorrar> y la
        cadena se devuelve sin ningún carácter a.adido. Por ejemplo,
        STUFF("Mi perro tiene pulgas.", 1, 3, "") devuelve "perro tiene
        pulgas".

     .  Sustituir e insertar: Si <cInsertar> es m.s largo que
        <nBorrar>, se sustituyen todos los carácteres desde <nInicio> hasta
        <nBorrar> y se inserta el resto de <cInsertar>. Puesto que se
        insertan m.s carácteres de los que se borran, la cadena resultante
        siempre es m.s larga que la original. Por ejemplo, STUFF("Mi perro
        tiene pulgas.", 10, 5, "nunca ha tenido") devuelve "Mi perro nunca ha
        tenido pulgas".

     .  Sustituir y borrar: Si la longitud de <cInsertar> es menor
        que <nBorrar>, se borran m.s carácteres de los que se insertan. Por
        lo tanto, la cadena resultante es m.s corta que la original. Por
        ejemplo, STUFF("Mi perro tiene pulgas.", 10, 5, "es") devuelve "Mi
        perro es pulgas".

     .  Sustituir y borrar el resto: Si <nBorrar> es mayor o igual
        que el número de carácteres restántes de <cCadena> empezando por
        <nInicio>, los carácteres restántes se borran antes de insertar
        <cInsertar>. Por ejemplo, STUFF("Mi perro tiene pulgas.", 10, 13,
        "es") devuelve "Mi perro es".

 Ejemplos

     .  Estos ejemplos demuestran las seis operación.s b.sicas de
        STUFF():

        // InsertAR
        ? STUFF("ABCDEF", 2, 0, "xyz")         // Resultado: AxyzBCDEF
        // Sustituir
        ? STUFF("ABCDEF", 2, 3, "xyz")         // Resultado: AxyzEF
        // Borrar
        ? STUFF("ABCDEF", 2, 2, "")            // Resultado: ADEF
        // Sustituir e insertar
        ? STUFF("ABCDEF", 2, 1, "xyz")         // Resultado: AxyzCDEF
        // Sustituir y borrar
        ? STUFF("ABCDEF", 2, 4, "xyz")         // Resultado: AxyzF
        // Sustituir y borrar resto
        ? STUFF("ABCDEF", 2, 10, "xyz")        // Resultado: Axyz

Ficheros: La biblioteca asociada es EXTEND.LIB,
           el módulo fuente asociado: SOURCE\SAMPLE\STUFF.C.


SUBSTR()
 Extrae una subcadena de una cadena de carácteres
------------------------------------------------------------------------------
 Sintaxis

     SUBSTR(<cCadena>, <nInicio>, [<nCaracteres>]) --> cSubcadena

 Argumentos

     <cCadena> es la cadena de carácteres de la que va a extraerse una
     subcadena. Puede tener hasta 65.535 (64K) bytes, el tama.o máximo de
     cadena en CA-Clipper.

     <nInicio> es la posición inicial en <cCadena>. Si <nInicio> es
     positivo, es relativo al carácter situado en el extremo izquierdo de
     <cCadena>. Si es negativo, es relativo al carácter situado en el extremo
     derecho de <cCadena>.

     <nCaracteres> es el número de carácteres que hay que extraer. Si se
     omite, la subcadena empieza en <nInicio> y continúa.hasta el final de la
     cadena. Si <nCaracteres> es mayor que el número de carácteres desde
     <nInicio> hasta el final de <cCadena>, los carácteres adicionales se
     ignoran.

 Devuelve

     SUBSTR() devuelve una cadena de carácteres.

 Descripción

     SUBSTR() es una función de carácteres que extrae una subcadena de otra
     cadena de carácteres o campo memo. SUBSTR() está relacionada con las
     funciónes LEFT() y RIGHT() que extraen subcadenas empezando por los
     carácteres situados m.s a la izquierda y a la derecha de <cCadena>,
     respectivamente.

     Las funciónes SUBSTR(), RIGHT() y LEFT() se utilizan muy a menudo con
     AT() y RAT() para localizar la primera y/o .ltima posición de una
     subcadena antes de extraerla. También se utilizan para mostrar o
     imprimir sólo una parte de una cadena de carácteres.

 Ejemplos

     .  Estos ejemplos extraen el nombre y apellido de una variable:

        cNombre:= "Juan Pedralbes"
        ? SUBSTR(cNombre, 1, 4)                      // Resultado: Juan
        ? SUBSTR(cNombre, 6)                         // Resultado: Pedralbes
        ? SUBSTR(cNombre, LEN(cNombre) + 2)          // Resultado:
                                                     // cadena nula
        ? SUBSTR(cNombre, -9)                        // Resultado: Pedralbes
        ? SUBSTR(cNombre, -9, 3)                     // Resultado: Ped

     .  Este ejemplo utiliza SUBSTR() con AT() y RAT() para crear una
        función que extrae un nombre de fichero de una especificación de
        fichero:

        ? FichBase("C:\PRG\MIFICHE.OBJ")             // Resultado: MIFICHE.OBJ

        FUNCTION FichBase( cFichero )
           LOCAL nPos
           IF (nPos := RAT("\", cFichero)) != 0
              RETURN SUBSTR(cFichero, nPos + 1)
           ELSEIF (nPos := AT(":", cFichero)) != 0
              RETURN SUBSTR(cFichero, nPos + 1)
           ELSE
              RETURN cFichero
           ENDIF

 Ficheros: La biblioteca asociada es CLIPPER.LIB.

Solo personas registradas pueden poner comentarios