EMPTY()
Determina si el resultado de una expresión es un valor vac.o ------------------------------------------------------------------------------ Sintaxis EMPTY(<exp>) --> lVac.o Argumentos <exp> es una expresión de cualquier tipo de datos. Devuelve EMPTY() devuelve verdadero (.T.) si la expresión es un valor vac.o; de lo contrario, devuelve falso (.F.). Los criterios para determinar si un valor se considera vac.o dependen del tipo de datos de <exp> de acuerdo con las reglas siguientes: Lista de Valores Vac.os ------------------------------------------------------------------------ Tipo de datos Contenido ------------------------------------------------------------------------ Matriz Longitud cero Car.cter Espacios, tabuladores, CR/LF, o ("") numérico 0 Fecha CTOD(" ") L.gico Falso (.F.) Memo Igual que carácter NIL NIL ------------------------------------------------------------------------ Descripción La función EMPTY() cuenta con diferentes útilizaciones. Puede utilizarla para determinar si un usuario ha introducido un valor en un objeto GET antes de realizar cambios en un fichero de base de datos. También puede determinar si un parámetro formal es NIL o no se ha pasado. Además, puede comprobar una matriz para localizar una longitud cero. Ejemplos . Estos ejemplos ilustran la utilización de EMPTY() frente a varios tipos de datos diferentes: ? EMPTY(SPACE(5)), EMPTY("") // Resultado: .T. .T. ? EMPTY(0), EMPTY(CTOD("")) // Resultado: .T. .T. ? EMPTY(.F.), EMPTY(NIL) // Resultado: .T. .T. . Este ejemplo utiliza EMPTY() para determinar si el usuario ha introducido un valor en el primer objeto Get antes de escribir el nuevo valor en el fichero de base de datos: LOCAL cCliente := SPACE(15), nCantidad := 0 USE Ventas NEW @ 10, 10 GET cCliente @ 11, 10 GET nCantidad PICTURE "999.99" READ // IF !EMPTY(cCliente) APPEND BLANK REPLACE Ventas->Cliente WITH cCliente; Ventas->Cantidad WITH nCantidad ENDIF . Este ejemplo utiliza EMPTY() como parte de la cláusula VALID para forzar al usuario a introducir datos en el objeto Get actual: LOCAL cCodigo := SPACE(5) @ 2, 5 SAY "Introduzca código" GET cCodigo VALID; !EMPTY(cCodigo) READ Ficheros: La biblioteca asociada es CLIPPER.LIB.


EOF()
 Determina cu.ndo se detecta el final del fichero
------------------------------------------------------------------------------
 Sintaxis

     EOF() --> lL.mite

 Devuelve

     EOF() devuelve verdadero (.T.) cuando se efect.a un intento de desplazar
     el puntero de registros sobrepasando el último registro l.gico de un
     fichero de base de datos; de lo contrario, devuelve falso (.F.). Si no
     hay fichero de base de datos abierto en el área de trabajo actual, EOF()
     devuelve falso (.F.). Si el fichero de base de datos actual no contiene
     registros, EOF() devuelve verdadero (.T.).

 Descripción

     EOF() es una función de base de datos utilizada para comprobar una
     condición l.mite de fin de fichero cuando el puntero del registro avanza
     por un fichero de base de datos. Cualquier mandato que pueda desplazar
     el puntero del registro puede establecer EOF().

     La aplicación m.s habitual es como una parte del argumento <lCondici.n>
     de una construcci.n DO WHILE que procesa secuencialmente registros en un
     fichero de base de datos. Aqu. <lCondici.n> incluir.a una comprobaci.n
     de .NOT. EOF(), forzando al bucle DO WHILE a terminar cuando EOF()
     devuelve verdadero (.T.).

     EOF() y FOUND() se utilizan, frecuentemente, de manera intercambiable
     para comprobar si un mandato SEEK, FIND, o LOCATE ha resultado fallido.
     Sin embargo, con estos mandatos es preferible FOUND().

     Cuando EOF() devuelve verdadero (.T.), el puntero del registro se sit.a
     en LASTREC() + 1 con independencia de si existe un filtro activo o si se
     ha establecido SET DELETED ON. Otros intentos de avanzar el puntero del
     registro devuelven el mismo resultado sin error. Una vez que EOF() est.
     establecido en verdadero (.T.), retiene su valor hasta que se produce
     otro intento de desplazar el puntero del registro.

     Por defecto, EOF() opera en el área de trabajo seleccionada actualmente.
     Se puede hacer que act.e en un área de trabajo no seleccionada
     especific.ndola dentro de una expresión con alias (consulte el ejemplo a
     continúa.ión).

 Ejemplos

     .  En este ejemplo se muestra el uso de EOF() desplazando
        deliberadamente el puntero del registro m.s all. del último registro:

        USE Ventas
        GO BOTTOM
        ? EOF()            // Resultado: .F.
        SKIP
        ? EOF()            // Resultado: .T.

     .  En este ejemplo se utilizan expresiónes con alias para
        consultar el valor de EOF() en .reas de trabajo no seleccionadas:

        USE Ventas NEW
        USE Cliente NEW
        ? Ventas->(EOF())
        ? Cliente->(EOF())

     .  En este ejemplo se ilustra c.mo EOF() puede utilizarse como
        parte de una condición para operación.s de ficheros de bases de datos
        secuenciales:

        USE Sales INDEX NumClie NEW
        DO WHILE !EOF()
           nClieAnt := Ventas->NumClie
           nCantTotal := 0
           DO WHILE nClieAnt = Ventas->NumClie .AND. (!EOF())
              ? Ventas->NumClie, Ventas->Descripción,
                    Ventas->CantVentas
              nCantTotal += Ventas->CantVentas
              SKIP
           ENDDO
           ? "Cantidad total: ", nCantTotal
        ENDDO

 Ficheros:  La biblioteca asociada es CLIPPER.LIB.


ERRORBLOCK()
 Establece un bloque de código para que se ejecute cuando surja un error de
 tiempo de ejecución
------------------------------------------------------------------------------
 Sintaxis

     ERRORBLOCK([<bManejadorError>]) --> bManejadorErrorActual

 Argumentos

     <bManejadorError> es el bloque de código que debe ejecutarse siempre
     que se produzca un error de tiempo de ejecución. Cuando se eval.a, el
     sistema pasa un objeto de error a <bManejadorError> como argumento.

 Devuelve

     ERRORBLOCK() devuelve el bloque de código de manejo de errores. Si no se
     ha fijado ningún bloque de manejo de errores desde que se llam. al
     programa, ERRORBLOCK() devuelve el bloque de manejo de errores por
     defecto.

 Descripción

     ERRORBLOCK() es una función de error que define la ejecución de un
     manejador de errores siempre que se produzca un error. Especifique el
     manejador de errores como un bloque de código con la forma siguiente:

     { |<objError>| <lista de expresiónes>,... }

     donde <objError> es un objeto error que contiene información sobre el
     error. Dentro del bloque de código, pueden envíarse mensajes al objeto
     con el fin de obtener información sobre el error. Si el bloque de manejo
     de errores devuelve verdadero (.T.) se reintenta la operación.fallida y
     si devuelve falso (.F.) se reanuda el proceso.

     El bloque de código de manejo de errores puede especificarse como una
     lista de expresiónes o como una llamada a una función definida por el
     usuario. La segunda opción es m.s .til puesto que pueden utilizarse las
     sentencias de control de CA-Clipper en lugar de expresiónes. Este es
     especialmente el caso si existe BEGIN SEQUENCE pendiente y desea
     efectuar BREAK a la sentencia RECOVER m.s pr.xima.

     Como esto implica, los bloques de manejo de errores pueden utilizarse en
     combinación con estructuras de control BEGIN SEQUENCE...END. En un
     bloque puede manejar errores de dispositivo, de bajo nivel y comunes que
     cuentan con un mecanismo de recuperaci.n general. Si la operación.     requiere un manejo espec.fico de errores, defina BEGIN SEQUENCE y
     después, BREAK a la sentencia RECOVER, devolviendo el objeto de error
     para el procesamiento local. Consulte el ejemplo que se muestra m.s
     adelante.

     Si no se ha especificado <bManejadorError> utilizando ERRORBLOCK() y se
     ha producido un error de tiempo de ejecución, se eval.a el bloque de
     manejo de errores por defecto. Este manejador de errores muestra un
     mensaje descriptivo en la pantalla, establece ERRORLEVEL() en 1 y
     después sale mediante QUIT del programa.

     Puesto que ERRORBLOCK() devuelve el bloque de manejo de errores actual,
     es posible especificar un bloque de manejo de errores para una operación.     guardando el bloque actual y restableci.ndolo después de que se haya
     completado la operación. Del mismo modo, los gestores de errores
     especificados como bloques de códigos, pueden pasarse a los
     procedimientos y funciónes definidas por el usuario y devolverse
     mediante RETURN como valores.

     Para obtener más información sobre la estructura y operación.s de
     objetos de error, consulte la entrada Clase de Error dentro de este
     capítulo y el capítulo Estrategias de Manejo de Errores en la gu.a
     Programaci.n y Utilidades.

 Ejemplos

     .  El fragmento de código de la p.gina siguiente establece un
        bloque de manejo de errores, que se llamar. cuando se produzca un
        error dentro de una construcci.n BEGIN SEQUENCE:

        LOCAL bManejadorError, búltimoManejador, objErr
        bManejadorError := { |objError| ;
              MiManejadorError(objError) }
        //
        // Guardar el manejador actual
        búltimoManejador := ERRORBLOCK(bManejadorError)
        //
        BEGIN SEQUENCE
           .
           . <sentencias de operación.gt;
           .
        // Recibir el objeto de error desde BREAK
        RECOVER USING objError
           .
           . <sentencias de recuperaci.n>
           .
        END
        ERRORBLOCK(búltimoManejador)         // Restaurar el
                                             // manejador
        RETURN

        FUNCTION MiManejadorError( objError )
           //
           BREAK objError                    // Devolver el objeto de
                                             // error a RECOVER
           RETURN NIL

 Ficheros: La biblioteca asociada es CLIPPER.LIB.


ERRORLEVEL()
 Establece el código de retorno de CA-Clipper
------------------------------------------------------------------------------
 Sintaxis

     ERRORLEVEL([<nNuevoC.digoRetorno>]) --> nC.digoRetornoActual

 Argumentos

     <nNuevoC.digoRetorno> es la nueva selecci.n de código de retorno.
     Esta puede tener un valor entre cero y 255. El valor por defecto al
     inicio es cero. Si no se especifica, ERRORLEVEL() informa sobre la
     selecci.n actual sin asignar un nuevo valor.

 Devuelve

     ERRORLEVEL() devuelve el código de salida de CA-Clipper actual como un
     valor numérico, si se ha seleccionado uno utilizando ERRORLEVEL() con un
     argumento; de lo contrario, devuelve cero.

 Descripción

     ERRORLEVEL() es una función de entorno que tiene una doble finalidad.
     Devuelve el código de retorno de CA-Clipper actual y establece,
     opciónalmente, un nuevo código de retorno. El código de retorno es un
     valor establecido por un proceso hijo de forma que el proceso padre
     pueda comprobar su estado de finalizaci.n. Normalmente, el proceso padre
     es el DOS y el hijo es un programa de aplicación. Puede comprobar el
     valor de retorno mediante la variable ERRORLEVEL del DOS o bien mediante
     la función 4Dh de la INT 21h.

     Cuando finaliza un programa de CA-Clipper, el código de retorno se
     establece en 1 si el proceso finaliza con un error grave. Si el proceso
     finaliza normalmente, el código de retorno se establece en cero o en el
     último valor de ERRORLEVEL() definido en el programa.

     Normalmente, puede fijar un código de retorno con ERRORLEVEL() para
     indicar un estado de error al programa que ha llamado al programa de
     CA-Clipper actual. En la mayor.a de casos, se trata del fichero de
     proceso por lotes de la aplicación. Aqu. puede comprobar el código de
     retorno utilizando la variable del DOS ERRORLEVEL. Consulte el manual de
     DOS para obtener más información.

 Notas

     .  ERRORLEVEL() no se actualiza después de que finalice un
        mandato RUN. Para obtener el código de retorno del programa llamado,
        debe crear una rutina en ensamblador o C que consulte el código de
        retorno del proceso secundario utilizando la función 4Dh de la INT
        21. Consulte el manual de Referencia T.cnica del DOS para obtener m.s
        información.

 Ejemplos

     .  Este ejemplo guarda el código de retorno actual de CA-Clipper,
        seguidamente, establece un nuevo valor:

        nAntCodigo := ERRORLEVEL()         // Obtiene el nivel
                                           // de error actual
        ERRORLEVEL(1)                      // Establece el nuevo
                                           // nivel de error

     .  Este ejemplo utiliza ERRORLEVEL() para establecer un código de
        retorno que puede comprobar el proceso padre:

        #define ERR_FICH_PERDIDO      255
        #define ERR_EST_INCOMPLETO    254
        //
        IF !FILE("Sisfich.dbf")
           @ 0, 0
           @ 1, 0
           @ 0, 0 SAY "Error fatal: Fichero de sistema perdido...saliendo"
           ERRORLEVEL(ERR_FICH_PERDIDO)
           QUIT
        ENDIF

 Ficheros: La biblioteca asociada es CLIPPER.LIB.


EVAL()
 Eval.a un bloque de código
------------------------------------------------------------------------------
 Sintaxis

     EVAL(<bBloque>, [<ListaArgBloque>]) --> últimoValorBloque

 Argumentos

     <bBloque> es el bloque de código que se debe evaluar.

     <ListaArgBloque> es una lista de argumentos para envíar al bloque de
     código antes de que se eval.e.

 Devuelve

     EVAL() devuelve el valor de la .ltima expresión dentro del bloque. Un
     bloque de código puede devolver un valor de cualquier tipo.

 Descripción

     EVAL() es una función de bloque de código. Es la función m.s b.sica de
     evaluaci.n de bloque de código del sistema CA-Clipper. Un bloque de
     código es un valor de datos especial que hace referencia a un fragmento
     de código de programa compilado. Para obtener más información sobre
     bloques de código, consulte el capítulo Conceptos Básicos de la gu.a
     Programaci.n y Utilidades.

     Para ejecutar o evaluar un bloque de código, llame a EVAL() con el valor
     de bloque y cualquier parámetro. Cuando se ejecuta el bloque se le
     suministran los parámetros. Los bloques de código pueden ser una serie
     de expresiónes separadas por comas. Cuando se eval.a un bloque de
     código, el valor de retorno es el valor de la .ltima expresión del
     bloque.

     Normalmente, el compilador de CA-Clipper compila un bloque de código en
     el tiempo de compilación. Sin embargo, existen ocasiones en las que es
     necesario compilar un bloque de código desde una cadena de carácteres en
     tiempo de ejecución. Este proceso puede realizarse utilizando el
     operador de macroexpresiónes (&).

     EVAL() se utiliza, con frecuencia, para crear funciónes de iteraci.n.
     Estas son funciónes que aplican un bloque a cada miembro de una
     estructura de datos. AEVAL(), ASORT(), ASCAN() y DBEVAL() son funciónes
     de iteraci.n (por ejemplo, AEVAL() eval.a un bloque para cada elemento
     de una matriz).

 Ejemplos

     .  En este ejemplo se crea un bloque de código que incrementa un
        número y despuésólo eval.a:

        bBloque := { |nArg| nArg + 1 }
        ? EVAL(bBloque, 1)                     // Resultado: 2

     .  En este ejemplo se muestra la compilación de un bloque de
        código en el tiempo de ejecución utilizando el operador de
        macroexpresiónes (&):

        // Compilar una cadena en un bloque
        bBloque := &("{ |nArg| nArg + 1 }")

        // Evaluar el bloque
        ? EVAL(bBloque, 1)

 Ficheros:  La biblioteca asociada es CLIPPER.LIB.


EXP()
 Calcula e**x
------------------------------------------------------------------------------
 Sintaxis

     EXP(<nExponente>) --> nAntilogaritmo

 Argumentos

     <nExponente> es el logaritmo natural para el que debe calcularse un
     valor numérico.

 Devuelve

     EXP() devuelve un valor numérico que es equivalente al valor e elevado a
     la potencia especificada.

 Descripción

     EXP() es una función matem.tica que calcula el valor de 'y' en la
     ecuaci.n siguiente:

     e**x = y

     Donde e es la base de logaritmos naturales (2,71828...) y x es
     <nExponente>. El valor máximo de <nExponente> es 45 antes de que se
     produzca un desbordamiento numérico. EXP() y LOG() son funciónes
     inversas.

     El número de posiciónes decimales que se muestra est. determinado
     .nicamente por SET DECIMALS con independencia del valor SET FIXED
     actual.

 Ejemplos

     .  En este ejemplo se muestran diversas llamadas a EXP():

        ? EXP(1)                  // Resultado: 2.72
        SET DECIMALS TO 10
        ? EXP(1)                  // Resultado: 2.7182818285
        ? LOG(EXP(1))             // Resultado: 1.0000000000

 Ficheros:  La biblioteca asociada es CLIPPER.LIB.


FCLOSE()
 Cierra un fichero binario abierto y escribe memorias intermedias del DOS en
 disco
------------------------------------------------------------------------------
 Sintaxis

     FCLOSE(<nManejador>) --> lError

 Argumentos

     <nManejador> es el manejador de fichero obtenido prevíamente de
     FOPEN() o FCREATE().

 Devuelve

     FCLOSE() devuelve falso (.F.) si se ha producido un error mientras
     estaba escribiendo; de lo contrario, devuelve verdadero (.T.).

 Descripción

     FCLOSE() es una función de fichero de bajo nivel que cierra ficheros
     binarios y fuerza a que las memorias intermedias asociadas del DOS se
     graben en disco. Si la operación.falla, FCLOSE() devuelve falso (.F.).
     FERROR() puede utilizarse para determinar el motivo del fallo. Por
     ejemplo, si intenta utilizar FCLOSE() con un manejador no víaacute;lido
     devuelve falso (.F.) y FERROR() devuelve el error 6 de DOS, manejador no
     víaacute;lido. Consulte FERROR() para obtener una lista completa de números de
     errores.

     .Advertencia! Esta función permite el acceso de bajo nivel a los
     ficheros y dispositivos del DOS. Debe utilizarse con gran precauci.n y
     requiere un conocimiento profundo del sistema operativo.

 Ejemplos

     .  Este ejemplo utiliza FCLOSE() para cerrar un fichero binario
        que se ha creado recientemente y muestra un mensaje de error si falla
        el proceso de cierre:

        #include "Fileio.ch"
        //
        nManejador := FCREATE("Fichprueba", FC_NORMAL)
        IF !FCLOSE(nManejador)

           ? "Error cerrando el fichero, error número: ", FERROR()
        ENDIF

 Ficheros:  La biblioteca asociada es CLIPPER.LIB.


FCOUNT()
 Devuelve el número de campos del fichero (.dbf) actual
------------------------------------------------------------------------------
 Sintaxis

     FCOUNT() --> nCampos

 Devuelve

     FCOUNT() devuelve el número de campos del fichero de base de datos en el
     área de trabajo actual como un valor numérico entero. Si no hay ningún
     fichero de base de datos abierto, FCOUNT() devuelve cero.

 Descripción

     FCOUNT() es una función de base de datos. Es .til en aplicaciónes que
     contienen programas independientes de los datos que pueden funciónar con
     cualquier fichero de base de datos. Estos incluyen programas
     generalizados de importaci.n/exportaci.n y de informes. Normalmente,
     debe utilizarse FCOUNT() para establecer el l.mite superior de un bucle
     FOR...NEXT o DO WHILE que procesa un campo cada vez.

     Por defecto, FCOUNT() funcióna en el área de trabajo seleccionada
     actualmente.

 Ejemplos

     .  Este ejemplo ilustra FCOUNT(), devolviendo el número de campos
        del área de trabajo actual y de una no seleccionada:

        USE Ventas NEW
        USE Cliente NEW
        ? FCOUNT()                      // Resultado: 5
        ? Ventas->(FCOUNT())            // Resultado: 8

     .  Este ejemplo utiliza FCOUNT() para declarar una matriz con
        información de campo:

        LOCAL aCampos := ARRAY(FCOUNT())
        AFIELDS(aCampos)

     .  Este ejemplo utiliza FCOUNT() como l.mite superior de un bucle
        FOR que procesa la lista de los campos del área de trabajo actual:

        LOCAL nCampo
        USE Ventas NEW
        FOR nCampo := 1 TO FCOUNT()
           ? FIELD(nCampo)
        NEXT

 Ficheros:  La biblioteca asociada es CLIPPER.LIB.



FCREATE()
 Crea y/o trunca un fichero binario a longitud cero
------------------------------------------------------------------------------
 Sintaxis

     FCREATE(<cFichero>, [<nAtributo>]) --> nManejador

 Argumentos

     <cFichero> es el nombre del fichero que va a crearse. Si el fichero
     ya existe, su longitud se trunca a cero sin aviso previo.

     <nAtributo> es uno de los atributos de fichero binario que se
     muestran en la tabla siguiente. Si se omite este argumento, el valor por
     defecto es cero.

     Atributos de Fichero Binario
     ------------------------------------------------------------------------
     Valor   Fileio.ch Atributo   Descripción
     ------------------------------------------------------------------------
     0       FC_NORMAL Normal     Crea un fichero de lectura/escritura normal
                                  (por defecto)
     1       FC_READONLY          S.lo lectura   Crea un fichero de sólo
                                  lectura
     2       FC_HIDDEN Oculto     Crea un fichero oculto
     4       FC_SYSTEM Sistema    Crea un fichero de sistema
     ------------------------------------------------------------------------

 Devuelve

     FCREATE() devuelve el número de manejador de fichero de DOS del nuevo
     fichero binario en el rango 0-65.535. Si se produce un error, FCREATE()
     devuelve -1 y FERROR() se establece de forma que indique un código de
     error.

 Descripción

     FCREATE() es una función de fichero de bajo nivel que crea un nuevo
     fichero o abre y trunca uno existente. Si <cFichero> no existe, se crea
     y se abre para escritura. Si existe y puede abrirse para escritura, se
     trunca a una longitud de cero. Si no puede abrirse para escritura,
     FCREATE() devuelve -1 y FERROR() devuelve el valor de error apropiado.

     Cuando FCREATE() crea un nuevo fichero de forma satisfactoria, .ste se
     deja abierto en modo compartido compatible y en el de acceso de
     lectura/escritura. El atributo de fichero especificado por el argumento
     <nAtributo> se aplica al nuevo fichero cuando se cierra, permitiendo la
     escritura en un fichero reci.n creado de sólo lectura. Si desea obtener
     una lista de modos de acceso, consulte FOPEN().

     Puesto que se requiere un manejador de ficheros para identificar un
     fichero abierto para otras funciónes de fichero, el valor de retorno de
     FCREATE() se asigna siempre a una variable para su utilización
     posterior.

     Al igual que otras funciónes de fichero, FCREATE() no utiliza los
     valores SET DEFAULT o SET PATH para su operación. En su lugar, escribe
     en el directorio actual del DOS a menos que se establezca una vía de
     forma expl.cita.

     .Advertencia!  Esta función permite el acceso de bajo nivel a los
     ficheros y dispositivos del DOS. Debe utilizarse con gran precauci.n y
     requiere un conocimiento profundo del sistema operativo.

 Ejemplos

     .  En este ejemplo se crea un fichero llamado Fichprueba y lo
        abre para lectura y escritura:

        #include "Fileio.ch"
        //
        IF (nManejador := FCREATE("Fichprueba", FC_NORMAL)) == -1
           ? "No se puede crear el fichero:", FERROR()
           BREAK
        ELSE
           FWRITE(nManejador, "Hola a todos")
           FCLOSE(nManejador)
        ENDIF

 Ficheros:  La biblioteca asociada es CLIPPER.LIB,
            el fichero de cabecera asociado es Fileio.ch.



FERASE()
 Borra un fichero del disco
------------------------------------------------------------------------------
 Sintaxis

     FERASE(<cFichero>) --> nExito

 Argumentos

     <cFichero> es el nombre del fichero que debe borrarse del disco
     incluyendo la extensión, opciónalmente precedido por una especificación
     de unidad y/o vía.

 Devuelve

     FERASE() devuelve -1 si la operación.falla y cero si es satisfactoria.
     En el caso de que se produzca un fallo, puede utilizarse FERROR() para
     determinar la naturaleza del error.

 Descripción

     FERASE() es una función de fichero que borra un fichero especificado del
     disco. FERASE() es igual que el mandato ERASE, pero devuelve un valor y
     puede especificarse dentro de una expresión. Cuando se llama a FERASE(),
     <cFichero> se borra del disco .nicamente si se encuentra en el
     directorio del DOS actual o en el directorio especificado, de forma
     expl.cita, como parte del nombre del fichero. Al igual que otras
     funciónes de fichero y mandatos, FERASE() no utiliza los valores de SET
     DEFAULT ni SET PATH para localizar <cFichero>.

     .Advertencia! Los ficheros deben cerrarse antes de borrarlos con
     FERASE().

 Ejemplos

     .  En este ejemplo se borra un conjunto de ficheros que coinciden
        con un patr.n comod.n:

        #include "Directry.ch"
        AEVAL(DIRECTORY("*.BAK"), { |aFichero| ;
           FERASE(aFichero[F_NAME]) })

     .  En este ejemplo se borra un fichero y se muestra un mensaje si
        falla la operación.

        IF FERASE("Fichero.txt") == -1
           ? "Error de borrado de archivo:", FERROR()
           BREAK
        ENDIF

 Ficheros: La biblioteca asociada es CLIPPER.LIB.


FERROR()
 Comprueba si existen errores después de una operación.de fichero binario
------------------------------------------------------------------------------
 Sintaxis

     FERROR() --> nC.digoError

 Devuelve

     FERROR() devuelve el error del DOS de la .ltima operación.de fichero
     como un valor numérico entero. Si no hay ningún error, FERROR() devuelve
     cero.

     Valores de Retorno de FERROR() 
     ------------------------------------------------------------------------
     Error     Significado
     ------------------------------------------------------------------------
     0         Satisfactorio
     2         Fichero no encontrado
     3         V.a no encontrada
     4         Demasiados ficheros abiertos
     5         Acceso denegado
     6         Manejador no víaacute;lido
     8         Memoria insuficiente
     15        Unidad especificada no víaacute;lida
     19        Ha intentado escribir en un disco protegido contra escritura
     21        Unidad no preparada
     23        Error CRC de datos
     29        Fallo de escritura
     30        Fallo de lectura
     32        Violaci.n de compartici.n
     33        Violaci.n de bloqueo
     ------------------------------------------------------------------------

 Descripción

     FERROR() es una función de fichero de bajo nivel que indica un error del
     DOS después de que se haya utilizado una función de fichero. Estas
     funciónes incluyen FCLOSE(), FCREATE(), FERASE(), FOPEN(), FREAD(),
     FREADSTR() y FRENAME(). FERROR() retiene su valor hasta la siguiente
     ejecución de una función de fichero.

     .Advertencia! Esta función permite el acceso de bajo nivel a los
     ficheros y dispositivos del DOS. Debe utilizarse con gran precauci.n y
     requiere un conocimiento profundo del sistema operativo

 Ejemplos

     .  Este ejemplo comprueba FERROR() después de crear un fichero
        binario y muestra un mensaje de error si falla la creaci.n:

        #include "Fileio.ch"
        //
        nManejador := FCREATE("Temp.txt", FC_NORMAL)
        IF FERROR() != 0
           ? "No se puede crear el fichero, error DOS ", FERROR()
        ENDIF

 Ficheros:  La biblioteca asociada es CLIPPER.LIB.


FIELDBLOCK()
 Devuelve un bloque de código de asignación/lectura de un campo determinado
------------------------------------------------------------------------------
 Sintaxis

     FIELDBLOCK(<cNombreCampo>) --> bBloqueCampo

 Argumentos

     <cNombreCampo> es el nombre del campo al que har. referencia el
     bloque de asignación/lectura.

 Devuelve

     FIELDBLOCK() devuelve un bloque de código que, cuando se eval.a, asigna
     o lee el valor del campo determinado. Si <cNombreCampo> no existe en el
     .rea de directorio actual, FIELDBLOCK() devuelve NIL.

 Descripción

     FIELDBLOCK() es una función de base de datos que crea un bloque de
     código. Cuando se ejecuta con un argumento, el bloque de código creado
     mediante esta función asigna el valor del argumento a <cNombreCampo>.
     Cuando se ejecuta sin un argumento, el bloque de código recupera el
     valor de <cNombreCampo>.

     Observe que es posible que la variable de campo especificada no exista
     cuando se cree el bloque de código, pero debe existir antes de que .ste
     se ejecute.

 Notas

     .  área de trabajo: El bloque de código devuelto por
        FIELDBLOCK() asigna o recupera el valor del campo especificado en
        cualquier área de trabajo en la que est. actualmente cuando se
        ejecute el bloque. Por ejemplo, las .reas de trabajo 1 y 2
        determinadas, contienen ambas el campo NomC:

        SELECT 1
        NomC := "Maribel"
        SELECT 2
        NomC := "Sonia"
        bNomC := FIELDBLOCK("NomC")
        SELECT 1
        ? EVAL(bNomC)          // Resultado: "Maribel"
        SELECT 2
        ? EVAL(bNomC)          // Resultado: "Sonia"

        La función FIELDWBLOCK() proporciona un bloque de asignación/lectura
        para un campo en un área de trabajo espec.fica.

 Ejemplos

     .  Este ejemplo compara FIELDBLOCK() con un bloque de código
        creado utilizando el operador de macroexpresiónes. Observe que
        utilizando FIELDBLOCK() evita los problemas de velocidad y tama.o
        asociados con el citado operador:

        // Bloque de asignación/lectura definido por medio del
        // operador de macroexpresiónes
        bAsilec := &( "{ |ValorAsig| IF( ValorAsig == NIL,;
                        NomC, NomC := ValorAsig ) }" )
        // Bloque de asignación/lectura definido por medio de
        // FIELDBLOCK()

        // bAsilec creado aqu. es el equivalente
        // funciónal del bAsilec anterior
        bAsilec := FIELDBLOCK("NomC")

 Ficheros:  La biblioteca asociada es CLIPPER.LIB.



FIELDGET()
 Obtiene el valor de un campo a partir de su posición en la estructura de
 la base de datos
------------------------------------------------------------------------------
 Sintaxis

     FIELDGET(<nCampo>) --> ValorCampo

 Argumentos

     <nCampo> es la posición ordinal del campo en la estructura de
     registro para el área de trabajo actual.

 Devuelve

     FIELDGET() devuelve el valor del campo especificado. Si <nCampo> no
     corresponde a la posición de ningún campo del fichero de base de datos
     actual, FIELDGET() devuelve NIL.

 Descripción

     FIELDGET() es una función de base de datos que obtiene el valor de un
     campo utilizando su posición dentro de la estructura del fichero de la
     base de datos en lugar de su nombre de campo. Dentro de las funciónes
     gen.ricas de servicio de base de datos esto permite, entre otras cosas,
     recuperar los valores de campos sin utilizar el operador de
     macroexpresiónes.

 Ejemplos

     .  Este ejemplo compara FIELDGET() con el código funciónalmente
        equivalente que utiliza el operador de macroexpresiónes para obtener
        el valor de un campo:

        LOCAL nCampo := 1, NomC, ValC
        USE Cliente NEW
        //
        // Usando el operador de macroexpresiónes
        NomC := FIELD( nCampo )           // Obtener el nombre
                                          // del campo
        ValC := &NomC                     // Obtener el valor
                                          // del campo
        // Usando FIELDGET()
        ValC := FIELDGET( nCampo )        // Obtener el valor
                                          // del campo

 Ficheros:  La biblioteca asociada es CLIPPER.LIB.


FIELDNAME()/FIELD()
 Devuelve un nombre de campo del fichero (.dbf) actual
------------------------------------------------------------------------------
 Sintaxis

     FIELDNAME/FIELD(<nPosici.n>) --> cNombreCampo

 Argumentos

     <nPosici.n> es la posición de un campo en la estructura del fichero
     de base de datos.

 Devuelve

     FIELDNAME() devuelve el nombre del campo especificado como una cadena de
     carácteres. Si <nPosici.n> no corresponde con un campo existente en el
     fichero de base de datos actual o si no se abre ningún fichero de base
     de datos en el área de trabajo actual, FIELDNAME() devuelve una cadena
     nula ("").

 Descripción

     FIELDNAME() es una función de base de datos que devuelve un nombre de
     campo utilizando un ííndice en la posición del nombre de campo en la
     estructura de base de datos. Util.celo en aplicaciónes independientes de
     los datos donde el nombre de campo es desconocido. Si requiere
     información de m.s de un campo, utilice AFIELDS() para crear una matriz
     de información de campos o COPY STRUCTURE EXTENDED para crear una base
     de datos de información de campos.

     Si necesita información adicional sobre estructuras de ficheros de base
     de datos, utilice TYPE() y LEN(). Para obtener el número de posiciónes
     decimales de un campo numérico, utilice la expresión siguiente:

     LEN(SUBSTR(STR(<idCampo>), RAT(".", ;
                 STR(<idCampo>)) + 1))

     Por defecto, FIELDNAME() funcióna en el área de trabajo seleccionada
     actualmente, tal como se muestra en el ejemplo siguiente.

 Ejemplos

     .  En estos ejemplos se ilutra FIELDNAME() utilizado con otras
        funciónes:

           USE Ventas
           ? FIELDNAME(1)                // Resultado: SUCURSAL
           ? FCOUNT()                    // Resultado: 5
           ? LEN(FIELDNAME(0))           // Resultado: 0
           ? LEN(FIELDNAME(40))          // Resultado: 0

     .  En este ejemplo se utiliza FIELDNAME() para listar el nombre y
        tipo de cada campo de Cliente.dbf:

           USE Cliente NEW

              FOR nCampo := 1 TO FCOUNT()
                 ? PADR(FIELDNAME(nCampo), 10),;
                        VALTYPE(&(FIELDNAME(nCampo)))
              NEXT

     .  En este ejemplo se accede a campos en .reas de trabajo no
        seleccionadas, utilizando expresiónes de alias:

              USE Ventas NEW
              USE Cliente NEW
              USE Facturas NEW
              //
              ? Ventas->(FIELDNAME(1))   // Resultado: NUMVENTA
              ? Cliente->(FIELDNAME(1))  // Resultado: NUMCLIE

 Ficheros:  La biblioteca asociada es CLIPPER.LIB.


FIELDPOS()
 Devuelve la posición de un campo en un área de trabajo
------------------------------------------------------------------------------
 Sintaxis

     FIELDPOS(<cNombreCampo>) --> nPosCampo

 Argumentos

     <cNombreCampo> es el nombre de un campo en el área de trabajo actual
     o especificada.

 Devuelve

     FIELDPOS() devuelve la posición del campo especificado dentro de la
     lista de campos asociados con el área de trabajo actual o especificada.
     Si el área de trabajo actual no tiene ningún campo con el nombre
     especificado, FIELDPOS() devuelve cero.

 Descripción

     FIELDPOS() es una función de base de datos que realiza el proceso
     inverso de la función FIELDNAME(). FIELDPOS() se utiliza frecuentemente
     junto con las funciónes FIELDPUT() y FIELDGET().

     FIELDPOS() devuelve los nombres de campos en cualquier área de trabajo
     no seleccionada, haciendo referencia a la función por medio de una
     expresión con alias. Consulte el ejemplo que se muestra m.s adelante.

 Ejemplos

     .  En este ejemplo se muestra una especificación t.pica de la
        función FIELDPOS():

     USE Cliente NEW

        ? FIELDPOS("Nombre")                   // Resultado: 1
        ? FIELDGET(FIELDPOS("Nombre"))         // Resultado: Sonia

     .  En este ejemplo se utiliza FIELDPOS() para devolver la
        posición de un campo especificado en un área de trabajo no
        seleccionada:

        USE Cliente NEW
        USE Facturas NEW
        ? Cliente->(FIELDPOS("Nombre"))        // Resultado: 1
        ? Cliente->(FIELDGET(FIELDPOS("Nombre")))
                                               // Resultado: Sonia

 Ficheros:  La biblioteca asociada es CLIPPER.LIB.


FIELDPUT()
 Establece el valor de una variable de campo a partir de su posición en
 la estructura de la base de datos
------------------------------------------------------------------------------
 Sintaxis

     FIELDPUT(<nCampo>, <expAsignar>) --> ValorAsignado

 Argumentos

     <nCampo> es la posición ordinal del campo en el fichero de base de
     datos actual.

     <expAsignar> es el valor que debe asignarse al campo dado. El tipo
     de datos de esta expresión debe coincidir con el tipo de datos de la
     variable de campo designada.

 Devuelve

     FIELDPUT() devuelve el valor asignado al campo designado. Si <nCampo> no
     corresponde con la posición de ningún campo del fichero de base de datos
     actual, FIELDPUT() devuelve NIL.

 Descripción

     FIELDPUT() es una función de base de datos que asigna <expAsignar> al
     campo en la posición ordinal <nCampo> en el área de trabajo actual. Esta
     función le permite establecer el valor de un campo utilizando su
     posición dentro de la estructura del fichero de base de datos en lugar
     de su nombre de campo. Dentro de las funciónes gen.ricas de servicio de
     base de datos esto permite, entre otras cosas, seleccionar valores de
     campo sin tener que utilizar el operador de macroexpresiónes.

 Ejemplos

     .  En este ejemplo se compara FIELDPUT() con el código
        funciónalmente equivalente, que utiliza el operador de
        macroexpresiónes para establecer el valor de un campo:

        // Usando el operador de macroexpresiónes
        NomC := FIELD(nCampo)            // Obtener nombre de campo
        FIELD->&NomC := ValC             // Establecer valor de campo
        // Usando FIELDPUT()
        FIELDPUT(nCampo, ValC)           // Establecer valor de campo

 Ficheros:  La biblioteca asociada es CLIPPER.LIB.


FIELDWBLOCK()
 Devuelve un bloque de código de asignación/lectura de un campo en un .rea
 de trabajo determinada
------------------------------------------------------------------------------
 Sintaxis

     FIELDWBLOCK(<cNombreCampo>, <nAreaTrabajo>) --> bBloqueCampoT

 Argumentos

     <cNombreCampo> es el nombre del campo especificado como una cadena
     de carácteres.

     <nAreaTrabajo> es el número de área de trabajo donde reside el campo
     especificado.

 Devuelve

     FIELDWBLOCK() devuelve un bloque de código que, cuando se eval.a, asigna
     u obtiene el valor de <cNombreCampo> en el área de trabajo designada por
     <nAreaTrabajo>. Si <cNombreCampo> no existe en el área de trabajo
     especificada, FIELDWBLOCK() devuelve NIL.

 Descripción

     FIELDWBLOCK() es una función de base de datos que crea un bloque de
     código. Cuando se eval.a el bloque de código con la función EVAL(), en
     primer lugar, selecciona el <nAreaTrabajo> designada. Si se ha pasado un
     argumento, el bloque de código asigna el valor del argumento a
     <cNombreCampo>. Si no se ha pasado ningún argumento, el bloque de código
     obtiene el valor de <cNombreCampo>. El área de trabajo original se
     vuelve a seleccionar antes de que el bloque de código devuelva el
     control.

     Observe que es posible que no exista la variable de campo especificada
     cuando se cree el bloque de código, pero debe existir antes de que se
     ejecute.

 Notas

     .  FIELDWBLOCK() es similar a FIELDBLOCK(), con la excepci.n de
        que FIELDWBLOCK() incorpora un área de trabajo fija en el bloque de
        asignación/lectura.

 Ejemplos

     .  Este ejemplo compara FIELDWBLOCK() con un bloque de código
        creado utilizando el operador de macro. Observe que utilizando
        FIELDWBLOCK() se evitan los problemas de velocidad y tama.o asociados
        con el operador de macroexpresiónes:

        // Bloque de asignación/lectura para el área de trabajo 1
        // definido con el operador de macroexpresiónes
        bAsilec := &( "{ |ValorAsig| IF( ValorAsig == NIL, ;
           1->NomC, 1->NomC := ValorAsig ) }" )
        // Bloque de asignación/lectura definido por medio de
        // FIELDWBLOCK()

        // bAsilec creado aqu. es el equivalente
        // funciónal del bAsilec anterior
        bAsilec := FIELDWBLOCK("NomC", 1)

 Ficheros:  La biblioteca asociada es CLIPPER.LIB.


FILE()
 Determina si existen ficheros en el directorio o vía por defecto de
 CA-Clipper
------------------------------------------------------------------------------
 Sintaxis

     FILE(<cEspecFichero>) --> lExiste

 Argumentos

     <cEspecFichero> determina una especificación de fichero estándar que
     puede incluir carácteres comod.n * y ?, as. como una referencia de
     unidad y de vía. Las referencias expl.citas a un fichero deben incluir
     también una extensión.

 Devuelve

     FILE() devuelve verdadero (.T.) si alg.n fichero coincide con el patr.n
     <cEspecFichero>; de lo contrario, devuelve falso (.F.).

 Descripción

     FILE() es una función de entorno que determina si se ha localizado alg.n
     fichero que coincida con un patr.n de especificación de fichero. FILE()
     busca el directorio especificado si se ha especificado una vía de forma
     expl.cita.

     Si no se ha especificado una vía, FILE() busca en el directorio por
     defecto de CA-Clipper y posteriormente, la vía de CA-Clipper. En ningún
     caso se busca en la vía del DOS. Observe también que FILE() no reconoce
     los ficheros ocultos o de sistema en su b.squeda.

 Ejemplos

     .  En este ejemplo FILE() intenta localizar Ventas.dbf en otro
        directorio de CA-Clipper, que no sea el utilizado por defecto:

        ? FILE("Ventas.dbf")                   // Resultado: .F.
        ? FILE("\APPS\DBF\Ventas.dbf")         // Resultado: .T.
        //
        SET PATH TO \APPS\DBF
        ? FILE("Ventas.dbf")                   // Resultado: .T.
        //
        SET PATH TO
        SET DEFAULT TO \APPS\DBF\
        ? FILE("Ventas.dbf")                   // Resultado: .T.
        ? FILE("*.dbf")                        // Resultado: .T.

 Ficheros:  La biblioteca asociada es CLIPPER.LIB.



FKLABEL()*
 Devuelve un nombre de tecla de función
------------------------------------------------------------------------------
 Sintaxis

     FKLABEL(<nTeclafunción>) --> cEtiqTecla

 Devuelve

     FKLABEL() devuelve una cadena de carácteres que representa el nombre de
     la tecla de función especificada por el argumento numérico,
     <nTeclafunción>. Si el argumento es menor que uno o mayor que 40, la
     función devuelve una cadena ("") nula.

 Descripción

     FKLABEL() es una función de compatibilidad que se utiliza para duplicar
     la función FKLABEL() en dBASE III PLUS. Como principio general, la
     utilización de esta función no es recomendable ni necesaria en
     CA-Clipper. Las teclas de función se etiquetan con Fn, donde n abarca de
     uno a 40 y corresponde directamente con el argumento FKLABEL().

 Ficheros:  La biblioteca asociada es EXTEND.LIB,
            el módulo fuente es SOURCE\SAMPLE\FKLABEL.PRG.



FKMAX()*
 Devuelve el número de teclas de función como una constante
------------------------------------------------------------------------------
 Sintaxis

     FKMAX() --> nTeclasfunción

 Descripción

     FKMAX() es una función de compatibilidad que se utiliza para duplicar la
     función FKMAX() en dBASE III PLUS. Como principio general, la
     utilización de esta función no es recomendable ni necesaria en
     CA-Clipper. Simplemente, devuelve un valor constante igual a 40.

 Ficheros:  La biblioteca asociada es EXTEND.LIB,
            el módulo fuente es SOURCE\SAMPLE\FKMAX.PRG.


FLOCK()
 Bloquea un fichero de base de datos abierto en modo compartido
------------------------------------------------------------------------------
 Sintaxis

     FLOCK() --> lExito

 Devuelve

     FLOCK() devuelve verdadero (.T.) si el intento de bloquear un fichero de
     base de datos en uso en el área de trabajo actual es satisfactorio; de
     lo contrario, devuelve falso (.F.). Si desea obtener más información
     sobre el bloqueo de ficheros, consulte el capítulo Programaci.n en Red
     en la gu.a Programaci.n y Utilidades.

 Descripción

     FLOCK() es una función de base de datos que se utiliza en entornos de
     red para bloquear un fichero de base de datos abierto en modo
     compartido, evitando as. que otros usuarios actualicen el fichero hasta
     que se libere el bloqueo. Los registros en el fichero bloqueado sólo
     están accesibles para operación.s de lectura.

     FLOCK() se relaciona con USE...EXCLUSIVE y RLOCK(). USE...EXCLUSIVE abre
     un fichero de base de datos, de forma que ningún otro usuario pueda
     abrir el mismo fichero al mismo tiempo y se trata del mecanismo de
     bloqueo m.s restrictivo de CA-Clipper. RLOCK() es el menos restrictivo e
     intenta situar un bloqueo de actualizaci.n en un registro compartido,
     impidiendo que otros usuarios actualicen el registro actual. FLOCK()
     representa un nivel de restricci.n medio.

     FLOCK() se utiliza en operación.s que acceden a la totalidad del fichero
     de base de datos. Normalmente, estos son mandatos que actualizan el
     fichero con un ámbito o una condición, como por ejemplo, DELETE o
     REPLACE ALL. A continúa.ión, se muestra una lista de estos mandatos:

     Mandatos que requieren FLOCK()
     ------------------------------------------------------------------------
     Mandato                       Modo
     ------------------------------------------------------------------------
     APPEND FROM                   FLOCK() o USE...EXCLUSIVE
     DELETE (varios registros)     FLOCK() o USE...EXCLUSIVE
     RECALL (varios registros)     FLOCK() o USE...EXCLUSIVE
     REPLACE (varios registros)    FLOCK() o USE...EXCLUSIVE
     UPDATE ON                     FLOCK() o USE...EXCLUSIVE
     ------------------------------------------------------------------------

     Por cada llamada de FLOCK(), existe un intento de bloquear el fichero de
     base de datos y el resultado se devuelve como un valor l.gico. Un
     bloqueo de fichero falla si otro usuario tiene actualmente un bloqueo de
     fichero o de registro para el mismo fichero de base de datos o bien, si
     otro usuario est. usando la base de datos en modo exclusivo. Si FLOCK()
     es satisfactorio, el bloqueo de fichero permanece hasta que efect.e
     UNLOCK, CLOSE DATABASE o RLOCK().

     Por defecto, FLOCK() funcióna en el área de trabajo seleccionada, tal
     como se muestra en el ejemplo siguiente.

 Notas

     .  SET RELATION: CA-Clipper no bloquea autom.ticamente todas
        las .reas de trabajo en la cadena de relaci.n cuando bloquea el .rea
        de trabajo actual y el uso de la función UNLOCK no es efectivo en
        .reas de trabajo relacionadas.

 Ejemplos

     .  Este ejemplo utiliza FLOCK() para una actualizaci.n por lotes
        de los precios de Inventar.dbf:

        USE Inventar NEW
        IF FLOCK()
           REPLACE ALL Inventar->Precio WITH ;
                 Inventar->Precio * 1.1
        ELSE
           ? "Fichero no disponible"
        ENDIF

     .  Este ejemplo utiliza una expresión con alias para intentar un
        bloqueo de fichero en un área de trabajo no seleccionada:

        USE Ventas NEW
        USE Cliente NEW
        //
        IF !Ventas->(FLOCK())
           ? "Ventas est. siendo usado por otro usuario"
        ENDIF

 Ficheros:  La biblioteca asociada es CLIPPER.LIB.



FOPEN()
 Abre un fichero binario
------------------------------------------------------------------------------
 Sintaxis

     FOPEN(<cFichero>, [<nModo>]) --> nManejador

 Argumentos

     <cFichero> es el nombre del fichero que se va a abrir incluyendo la
     vía, si existe.

     <nModo> es el modo de apertura del DOS solicitado, que indica c.mo
     puede accederse al fichero abierto. El modo de apertura se compone de
     elementos de los dos tipos de modos que se describen en las tablas que
     aparecen m.s adelante. Si .nicamente se utiliza el Modo de Acceso, el
     fichero se abre como no compartido. El modo de apertura por defecto es
     cero, lo que indica no compartido y sólo de lectura.

     Modos de Acceso FOPEN() 
     ------------------------------------------------------------------------
     Modo    Fileio.ch            Operaci.n
     ------------------------------------------------------------------------
     0       FO_READ              Abierto para lectura (por defecto)
     1       FO_WRITE             Abierto para escritura
     2       FO_READWRITE         Abierto para lectura o escritura
     ------------------------------------------------------------------------


     Los Modos de Utilizaci.n Compartida determinan c.mo pueden acceder otros
     procesos al fichero.

     Los Modos de Acceso en combinación (+) con los modos Compartidos
     determinan la accesibilidad del fichero en un entorno de red.

     Modos de Utilizaci.n Compartida FOPEN() 
     ------------------------------------------------------------------------
     Modo    Fileio.ch           Operaci.n
     ------------------------------------------------------------------------
     0       FO_COMPAT           Modo de compatibilidad (por defecto)
     16      FO_EXCLUSIVE        Uso exclusivo
     32      FO_DENYWRITE        Evita que otros escriban
     48      FO_DENYREAD         Evita que otros lean
     64      FO_DENYNONE         Permite que otros lean o escriban
     64      FO_SHARED           Igual que FO_DENYNONE
     ------------------------------------------------------------------------

 Devuelve

     FOPEN() devuelve el manejador del fichero abierto en el rango 0-65.535.
     Si se produce un error, FOPEN() devuelve -1.

 Descripción

     FOPEN() es una función de fichero de bajo nivel, que abre un fichero
     binario existente para lectura y escritura, según el argumento <nModo>.
     Siempre que exista un error de apertura, FERROR() devuelve el número de
     error del DOS. Por ejemplo, si el fichero no existe, FOPEN() devuelve -1
     y FERROR() devuelve 2 para indicar que no se ha localizado el fichero.
     Consulte FERROR() para obtener una lista completa de números de error.

     Si el fichero especificado se abre de forma satisfactoria, el valor
     devuelto es el manejador del DOS para el fichero. Este valor es similar
     a un alias en el sistema de base de datos y es necesario para
     identificar el fichero abierto para otras funciónes de fichero. Por lo
     tanto, es importante asignar el valor de retorno a una variable para su
     utilización posterior, tal como se muestra en el ejemplo que aparece m.s
     adelante.

     .Advertencia! Esta función permite el acceso de bajo nivel a los
     ficheros y dispositivos del DOS. Debe utilizarse con gran precauci.n y
     requiere un conocimiento profundo del sistema operativo.

 Notas

     .  Acceso a ficheros en otros directorios: FOPEN() no act.a
        seg.n los valores de SET DEFAULT ni SET PATH. En su lugar, busca en
        el directorio y vía actual del DOS, a menos que se establezca una
        vía, de forma expl.cita, como parte del argumento <cFichero>.

 Ejemplos

     .  Este ejemplo utiliza FOPEN() para abrir un fichero con estado
        compartible de lectura/escritura y muestra un mensaje de error si
        falla la apertura:

        #include "Fileio.ch"
        //
        nManejador := FOPEN("Temp.txt", FO_READWRITE + FO_SHARED)
        IF FERROR() != 0
           ? "No se puede abrir el fichero, error DOS", FERROR()
           BREAK
        ENDIF

 Ficheros:  La biblioteca asociada es CLIPPER.LIB,
            el fichero de cabecera asociado es Fileio.ch.


FOUND()
 Determina si se encontr. el registro buscado en la anterior operación. de b.squeda
------------------------------------------------------------------------------
 Sintaxis

     FOUND() --> lExito

 Devuelve

     FOUND() devuelve verdadero (.T.) si el último mandato de b.squeda ha
     sido satisfactorio; de lo contrario, devuelve falso (.F.).

 Descripción

     FOUND() es una función de base de datos que determina si una operación.     de b.squeda (es decir, FIND, LOCATE, CONTINUE, SEEK o SET RELATION) ha
     sido satisfactoria. Cuando se ejecuta uno de estos mandatos, FOUND()
     devuelve verdadero (.T.) si encuentra una coincidencia; de lo contrario,
     devuelve falso (.F.).

     Si el mandato de b.squeda es LOCATE o CONTINUE, una coincidencia es el
     siguiente registro que cumpla con el ámbito y la condición. Si el
     mandato de b.squeda es FIND, SEEK o SET RELATION, una coincidencia es la
     primera clave del índice de control que es igual al argumento de
     b.squeda. Si el valor clave es igual al argumento de b.squeda, FOUND()
     devuelve verdadero (.T.); de lo contrario, es falso (.F.).

     El valor de FOUND() se retiene hasta que se ejecuta otro mandato de
     movimiento de registro. A menos que sea otro mandato de b.squeda,
     FOUND() se establece autom.ticamente en falso (.F.).

     Cada área de trabajo tiene un valor FOUND(). Esto significa que si un
     área de trabajo tiene una relaci.n establecida con un área de trabajo
     secundaria, la consulta de FOUND() en el .rea secundaria devuelve
     verdadero (.T.) si encuentra una coincidencia.

     Por defecto, FOUND() act.a en el área de trabajo seleccionada
     actualmente. Puede hacer que funcióne en un área de trabajo no
     seleccionada especific.ndola dentro de una expresión de alias (consulte
     el ejemplo siguiente).

     FOUND() devuelve falso (.F.) si no hay ningúna base de datos abierta en
     el área de trabajo actual.

 Ejemplos

     .  En este ejemplo se ilustra el comportamiento de FOUND()
        después de un mandato de movimiento de registro:

        USE Ventas INDEX Ventas
        ? INDEXKEY(0)              // Resultado: VENDEDOR
        SEEK "1000"
        ? FOUND()                  // Resultado: .F.
        SEEK "100"
        ? FOUND()                  // Resultado: .T.
        SKIP
        ? FOUND()                  // Resultado: .F.

     .  En este ejemplo se comprueba un valor FOUND() en un .rea de
        trabajo no seleccionada utilizando una expresión de alias:

     USE Ventas INDEX Ventas NEW
        USE Cliente INDEX Cliente NEW
        SET RELATION TO Numclien INTO Ventas

        //
        SEEK "Casanova"
        ? FOUND(), Ventas->(FOUND())

     .  Este fragmento de código procesa todos los registros de
        Cliente con el valor clave "Casanova" utilizando FOUND() para
        determinar cu.ndo cambian los valores clave:

        USE Cliente INDEX Cliente NEW
        SEEK "Casanova"
        DO WHILE FOUND()
           .
           . <sentencias>
           .
           SKIP
           LOCATE REST WHILE Nombre == "Casanova"
        ENDDO

 Ficheros:  La biblioteca asociada es CLIPPER.LIB.


FREAD()
 Lee carácteres de un fichero binario en una variable de memoria intermedia
------------------------------------------------------------------------------
 Sintaxis

     FREAD(<nManejador>, @<cVarMemInter>, <nBytes>) --> nBytes

 Argumentos

     <nManejador> es el manejador de fichero que se obtiene de FOPEN(),
     FCREATE() o predefinido por el DOS.

     <cVarMemInter> es el nombre de una variable de carácter inicializada
     y existente que se utiliza para almacenar datos le.dos de un fichero
     especificado. La longitud de esta variable debe ser mayor que o igual a
     <nBytes>. <cVarMemInter> debe pasarse por referencia y, por lo tanto,
     debe ir precedida por el operador pasar por referencia (@).

     <nBytes> es el número de bytes que deben leerse en la memoria
     intermedia.

 Devuelve

     FREAD() devuelve el número de bytes le.dos satisfactoriamente como un
     valor numérico entero. Un valor de retorno menor que <nBytes> o cero
     indica el final del fichero o cualquier otro error de lectura.

 Descripción

     FREAD() es una función de fichero de bajo nivel que lee carácteres de un
     fichero binario en una variable de carácteres existente. Lee el fichero
     comenzando en la posición del puntero de fichero del DOS, avanzando
     dicho puntero el número de bytes le.dos. Se leen todos los carácteres
     incluyendo los de control, nulos y los de código ASCII superior a 127.

     FREAD() es similar en ciertos aspectos a FREADSTR() y FSEEK().
     FREADSTR() lee un número especificado de bytes de un fichero hasta el
     carácter nulo siguiente (CHR(0)). FSEEK() desplaza el puntero del
     fichero sin leer.

     Si surge un error durante la lectura del fichero, FERROR() devuelve el
     número de error del DOS. Consulte FERROR() para obtener una lista de
     números de error.

     .Advertencia! Esta función permite el acceso de bajo nivel a los
     ficheros y dispositivos del DOS. Debe utilizarse con gran precauci.n y
     requiere un conocimiento profundo del sistema operativo.

 Ejemplos

     .  Este ejemplo utiliza FREAD() después de abrir un fichero, de
        forma satisfactoria, para leer 128 bytes en un .rea de memoria
        intermedia:

        #define BLOQUE_F      128
        //
        cMemInter := SPACE(BLOQUE_F)
        nManejador := FOPEN("Temp.txt")
        //
        IF FERROR() != 0
           ? "Error de apertura de fichero:", FERROR()
        ELSE
           IF FREAD(nManejador, @cMemInter, BLOQUE_F) <> BLOQUE_F
              ? "Error de lectura en Temp.txt"
           ENDIF
           FCLOSE(nManejador)
        ENDIF

 Ficheros:  La biblioteca asociada es CLIPPER.LIB.



FREADSTR()
 Lee carácteres de un fichero binario
------------------------------------------------------------------------------
 Sintaxis

     FREADSTR(<nManejador>, <nBytes>) --> cCadena

 Argumentos

     <nManejador> es el manejador de ficheros obtenido de FOPEN(),
     FCREATE() o predefinido por el DOS.

     <nBytes> es el número de bytes que deben leerse, comenzando en la
     posición del puntero del fichero del DOS actual.

 Devuelve

     FREADSTR() devuelve una cadena de carácteres de un máximo de 65.535
     (64K) bytes. Un valor de retorno nulo ("") indica un error o el final
     del fichero.

 Descripción

     FREADSTR() es una función de fichero de bajo nivel que lee carácteres de
     un fichero binario abierto que comienza en la posición de puntero del
     fichero del DOS actual. Los carácteres se leen hasta <nBytes> o hasta
     que se encuentra un carácter nulo (CHR(0)). Se leen todos los carácteres
     incluyendo los de control, con la excepci.n de CHR(0). El puntero del
     fichero avanza <nBytes>. Si este número es mayor que el número de bytes
     desde la posición del puntero hasta el final del fichero, el puntero se
     sit.a en el último byte del fichero.

     .Advertencia! Esta función permite el acceso de bajo nivel a los
     ficheros y dispositivos del DOS. Debe utilizarse con gran precauci.n y
     requiere un conocimiento profundo del sistema operativo.

 Ejemplos

     .  El ejemplo de la p.gina siguiente muestra los valores ASCII de
        los primeros 16 bytes de un fichero de texto:

        #include "Fileio.ch"
        //
        nManejador := FOPEN("Nuevo.txt", FC_NORMAL)
        IF FERROR() != 0
           ? "Error de apertura de fichero:", FERROR()
        ELSE
           cCadena := FREADSTR(nManejador, 16)
           ? cCadena
           FCLOSE(nManejador)
        ENDIF

 Ficheros:  La biblioteca asociada es CLIPPER.LIB.



FRENAME()
 Cambia el nombre de un fichero
------------------------------------------------------------------------------
 Sintaxis

     FRENAME(<cFicheroAntiguo>, <cNuevoFichero>) --> nExito

 Argumentos

     <cFicheroAntiguo> es el nombre del fichero que debe renombrarse,
     incluyendo su extensión. También puede incluirse la letra de la unidad
     y/o nombre de vía, como parte del nombre del fichero.

     <cNuevoFichero> es el nuevo nombre del fichero, incluyendo su
     extensión. También puede incluirse la letra de la unidad y/o nombre de
     vía como parte del nombre.

 Devuelve

     FRENAME() devuelve -1 si la operación.falla y cero si es satisfactoria.
     En el caso de que se produzca un fallo, puede utilizarse FERROR() para
     determinar la naturaleza del error.

 Descripción

     FRENAME() es una función de fichero que cambia el nombre de un fichero
     especificado por uno nuevo y act.a de forma id.ntica al mandato RENAME.

     Cuando se llama FRENAME(), el <cFicheroAntiguo> sólo se renombra si est.
     situado en el directorio del DOS actual o en la vía especificada.
     FRENAME() no utiliza los valores de SET DEFAULT o SET PATH para
     localizar <cFicheroAntiguo>.

     Si el directorio fuente es diferente del directorio destáno, el fichero
     se desplaza al directorio destáno. En el caso de que exista
     <cNuevoFichero> o est. abierto actualmente, FRENAME() falla y devuelve -
     1, indicando que no ha realizado la acci.n designada. Con FERROR() puede
     determinarse la naturaleza del error.

     .Advertencia! Los ficheros deben cerrarse antes de renombrarlos. Si
     se intenta renombrar un fichero abierto pueden producirse resultados
     impredecibles. Cuando se renombra un fichero de base de datos, el
     fichero memo asociado (.dbt) también debe renombrarse. Si no lo hace de
     este modo, puede poner en peligro la integridad de sus bases de datos.

 Ejemplos

     .  En este ejemplo se muestra c.mo se renombra un fichero:

        IF FRENAME("FichAnt.txt", "NuevFich.txt") == -1
           ? "Error de fichero:", FERROR()
        ENDIF

 Ficheros:  La biblioteca asociada es CLIPPER.LIB.


FSEEK()
 Sitúa el puntero de fichero binario en una nueva posición
------------------------------------------------------------------------------
 Sintaxis

     FSEEK(<nManejador>, <nDesplazamiento>, [<nOrigen>]) --> nPosici.n

 Argumentos

     <nManejador> es el manejador de ficheros obtenido de FOPEN(),
     FCREATE() o predefinido por el DOS.

     <nDesplazamiento> es el número de bytes que se va a desplazar el
     puntero del fichero desde la posición definida por <nOrigen>. Puede ser
     un número positivo o negativo. Un número positivo desplaza el puntero
     hacia adelante y uno negativo lo desplaza hacia atr.s en el fichero.

     <nOrigen> define la situaci.n inicial del puntero del fichero antes
     de que se ejecute FSEEK(). El valor por defecto es cero, representando
     el inicio del fichero. Si <nOrigen> es el final del fichero,
     <nDesplazamiento> debe ser cero o negativo.

     M.todos para Desplazar el Puntero del Fichero
     ------------------------------------------------------------------------
     Origen   Fileio.ch      Descripción
     ------------------------------------------------------------------------
     0        FS_SET         Busca desde el principio del fichero
     1        FS_RELATIVE    Busca desde la posición actual del puntero
     2        FS_END         Busca desde el final del fichero
     ------------------------------------------------------------------------

 Devuelve

     FSEEK() devuelve la nueva posición del puntero del fichero relativa al
     inicio del fichero (posición 0) como un valor numérico entero. Este
     valor es independiente de la posición original del puntero del fichero.

 Descripción

     FSEEK() es una función de fichero de bajo nivel que desplaza el puntero
     del fichero hacia adelante o hacia atr.s en un fichero binario abierto
     sin leer realmente el contenido del fichero especificado. La posición
     inicial y desplazamiento se especifican como argumentos de función y se
     devuelve la nueva posición en el fichero. Independientemente de los
     argumentos de función especificados, el puntero del fichero no puede
     desplazarse de forma que exceda los l.mites del inicio o final del
     fichero.

     .Advertencia! Esta función permite el acceso de bajo nivel a
     ficheros y dispositivos del DOS. Debe utilizarse con gran precauci.n y
     requiere un conocimiento profundo del sistema operativo.

 Ejemplos

     .  En este ejemplo se utiliza FSEEK() para determinar la longitud
        de un fichero buscando desde el final del mismo. Seguidamente, el
        puntero se restablece al inicio del fichero:

     #include "Fileio.ch"

        //
        // Abrir el fichero en modo de sólo lectura
        IF (nManejador := FOPEN("Temp.txt")) >= 0
           //
           // Obtener la longitud del fichero
           nLongitud := FSEEK(nManejador, 0, FS_END)
           //
           // Restablecer la posición al comienzo del
           // fichero
           FSEEK(nManejador, 0)
           FCLOSE(nManejador)
        ELSE
           ? "Error de apertura de fichero:", FERROR()
        ENDIF

     .  Esta pseudofunción sit.a el puntero del fichero en el último
        byte de un fichero binario:

        #define FinalFichero(nManejador);
              (FSEEK(nManejador, 0, FS_END))

     .  Esta pseudofunción sit.a el puntero del fichero en el primer
        byte de un fichero binario:

        #define InicioFichero(nManejador);
              (FSEEK(nManejador, 0))

     .  Esta pseudofunción informa de la posición actual del puntero
        del fichero en un fichero binario especificado:

        #define PosFichero(nManejador);
              (FSEEK(nManejador, 0, FS_RELATIVE))

 Ficheros:  La biblioteca asociada es CLIPPER.LIB,
            el fichero de cabecera asociado es Fileio.ch.


FWRITE()
 Escribe en un fichero binario abierto
------------------------------------------------------------------------------
 Sintaxis

     FWRITE(<nManejador>, <cMemInter>, [<nBytes>]) --> nBytesEscritos

 Argumentos

     <nManejador> es el manejador de ficheros obtenido de FOPEN(),
     FCREATE() o predefinido por el DOS.

     <cMemInter> es la cadena de carácteres que debe escribirse en el
     fichero especificado.

     <nBytes> indica el número de bytes que debe escribirse, comenzando
     en la posición del puntero de fichero actual. Si se omite, se escribe
     todo el contenido de <cMemInter>.

 Devuelve

     FWRITE() devuelve el número de bytes escritos como un valor numérico
     entero. Si el valor devuelto es igual a <nBytes>, la operación.ha
     resultado satisfactoria. Si el valor de retorno es menor que <nBytes> o
     es cero, es debido a que el disco est. lleno o se ha producido otro
     error.

 Descripción

     FWRITE() es una función de fichero de bajo nivel que escribe datos en un
     fichero binario abierto desde una memoria intermedia de cadena de
     carácteres. Puede escribir todo el contenido de la memoria intermedia o
     tan sólo una parte. La escritura comienza en la posición actual del
     fichero y la función devuelve el número real de bytes escritos.

     Si FWRITE() produce una condición de error, puede utilizar FERROR() para
     determinar el error espec.fico.

     .Advertencia! Esta función permite el acceso de bajo nivel a los
     ficheros y dispositivos del DOS. Debe utilizarse con gran precauci.n y
     requiere un profundo conocimiento del sistema operativo

 Ejemplos

     .  En este ejemplo se copia el contenido de un fichero en otro:

        #include "Fileio.ch"
        #define BLOQUE_F      512
        //
        cMemInter := SPACE(BLOQUE_F)
        nFichEnt := FOPEN("Temp.txt", FO_READ)
        nFichSal := FCREATE("NuevFich.txt", FC_NORMAL)
        lHecho := .F.
        //
        DO WHILE !lHecho
           nBytesLec := FREAD(nFichEnt, @cMemInter, BLOQUE_F)
           IF FWRITE(nFichSal, cMemInter, nBytesLec) < ;
                       nBytesLec
              ? "Fallo de escritura: ", FERROR()
              lHecho := .T.
           ELSE
              lHecho := (nBytesLec == 0)
           ENDIF
        ENDDO
        //
        FCLOSE(nFichEnt)
        FCLOSE(nFichSal)

 Ficheros:  La biblioteca asociada es CLIPPER.LIB.


GETENV()
 Obtiene el contenido de una variable de entorno DOS
------------------------------------------------------------------------------
 Sintaxis

     GETENV(<cVariableEntorno>) --> cCadena

 Argumentos

     <cVariableEntorno> es el nombre de la variable de entorno del DOS.
     Cuando se especifica este argumento, puede utilizarse cualquier
     combinación de letras mayúsculas y minúsculas; GETENV() no es sensible a
     las mayúsculas y minúsculas.

 Devuelve

     GETENV() devuelve el contenido de la variable de entorno del DOS
     especificada como una cadena de carácteres. Si no se puede localizar la
     variable, GETENV() devuelve una cadena nula ("").

 Descripción

     GETENV() es una función de entorno que le permite obtener información
     del entorno DOS en un programa de aplicación. Normalmente, .sta es la
     información de la configuración, incluyendo los nombres de vía que
     proporcionan la situaci.n de los ficheros (base de datos, índice,
     etiqueta o informes). Esta función es particularmente .til en entornos
     de red.

 Notas

     .  Valor de retorno vac.o: Si est. seguro de que existe una
        variable de entorno y GETENV() devuelve siempre una cadena nula (""),
        aseg.rese de que no existen espacios entre el nombre de variable de
        entorno y el primer carácter de la cadena que se le ha asignado en el
        mandato SET del DOS.

     .  Compatibilidad: En las versiones anteriores de CA-Clipper,
        la función se llamaba GETE(). Esta forma abrevíada de GETENV() es
        todavía operativa.

 Ejemplos

     .  Este ejemplo obtiene el valor actual de PATH del DOS,
        convirti.ndola en la vía actual de CA-Clipper:

        cVia := GETENV("PATH")
        SET PATH TO (cVia)

     .  Este ejemplo utiliza variables de entorno para configurar las
        posiciónes espec.ficas de ficheros. Cuando se configura un sistema,
        se definen variables de entorno que contienen la posición de varios
        tipos de fichero as. como la variable de entorno CLIPPER (consulte el
        capítulo Entorno de Ejecuci.n en la gu.a Programaci.n y Utilidades),
        de forma an.loga a lo siguiente:

        C>SET LOC_DBF=<vía de fichero de base de datos>
        C>SET LOC_NTX=<vía de fichero de índice>
        C>SET LOC_RPT=<vía de fichero de informe>

        En la secci.n de configuración del programa de aplicación, asigne el
        contenido de las variables de entorno a variables. Posteriormente,
        cuando acceda a un fichero, haga preceder la referencia con la
        variable de vía, del modo siguiente:

        cDdfDirectorio := GETENV("LOC_DBF")
        USE (cDdfDirectorio + "Facturas")

 Ficheros:  La biblioteca asociada es CLIPPER.LIB.



HARDCR()
 Sustituye los retornos de carro autom.ticos de una cadena de carácteres por
 retornos de carro forzados.
------------------------------------------------------------------------------
 Sintaxis

     HARDCR(<cCadena>) --> cCadenaConvertida

 Argumentos

     <cCadena> es la cadena de carácteres o campo memo que se va a
     convertir.

 Devuelve

     HARDCR() devuelve una cadena de carácteres de hasta 65.535 (64K)
     carácteres de longitud.

 Descripción

     HARDCR() es una función memo que sustituye todos los retornos de carro
     autom.ticos (CHR(141)) por retornos de carro forzados (CHR(13)). Se
     utiliza para mostrar con mandatos de consola cadenas de carácteres
     largas y campos memo que contienen retornos de carro autom.tico. En
     CA-Clipper los mandatos de consola (incluyendo REPORT y LABEL FORM) no
     convierten autom.ticamente los retornos de carro autom.ticos en retornos
     permanentes, por lo que es necesario hacer explícitamente la conversión.
     MEMOEDIT() a.ade retornos de carro autom.ticos en los saltos de línea.

 Notas

     .  HARDCR() en REPORT y LABEL FORM: Si se utiliza HARDCR() en
        una expresión de contenido de REPORT FORM o LABEL FORM y no se
        utiliza en otra parte, debe declararse EXTERNAL para asegurarse de
        que est. enlazada.

 Ejemplos

     .  Para mostrar un campo memo formateado con los saltos de línea
        autom.ticos de MEMOEDIT():

        USE Ventas NEW
        ? HARDCR(Ventas->Notas)

 Ficheros:  La biblioteca asociada es EXTEND.LIB.


HEADER()
 Devuelve la longitud de la cabecera del fichero de base de datos actual
------------------------------------------------------------------------------
 Sintaxis

     HEADER() --> nBytes

 Devuelve

     HEADER() devuelve el número de bytes de la cabecera del fichero de base
     de datos actual, en forma de número entero. Si no se est. utilizando
     ningún fichero de base de datos, HEADER() devuelve cero.

 Descripción

     HEADER() es una función de base de datos que se utiliza con LASTREC(),
     RECSIZE() y DISKSPACE() para crear procedimientos de copia de seguridad
     de ficheros.

     Por defecto, HEADER() act.a en el área de trabajo actualmente
     seleccionada. Para que act.e en un área de trabajo no seleccionada debe
     especificarse como parte de una expresión de alias (consulte el ejemplo
     siguiente).

 Ejemplos

     .  Este ejemplo determina el tama.o de la cabecera de Ventas.dbf:

        USE Ventas NEW
        ? HEADER()            // Resultado: 258

     .  Este ejemplo define una pseudofunción, TamaFich(), que utiliza
        HEADER() con RECSIZE() y LASTREC() para calcular el tama.o en bytes
        del fichero en base de datos actual:

        #define TamaFich()      ((RECSIZE() * LASTREC()) + ;
              HEADER() + 1)

        En adelante, puede utilizar TamaFich() igual que cualquier otra
        función:

        USE Ventas NEW
        USE Cliente NEW
        ? TamaFich()
        ? Ventas->(TamaFich())

 Ficheros:  La biblioteca asociada es EXTEND.LIB.


I2BIN()
 Convierte un valor numérico de CA-Clipper en un entero binario de 16 bits.
------------------------------------------------------------------------------
 Sintaxis

     I2BIN(<nEntero>) --> cEnteroBinario

 Argumentos

     <nEntero> es el número entero que se va a convertir. Los números
     decimales se truncan.

 Devuelve

     I2BIN() devuelve una cadena de carácteres de 2 bytes que contiene un
     entero binario de 16 bits.

 Descripción

     I2BIN() es una función de bajo nivel que convierte un número entero en
     una cadena de carácteres formateada como un entero binario (byte menos
     significativo primero). I2BIN() se utiliza con FWRITE() para convertir
     un número de CA-Clipper a la forma binaria estándar. La inversa de
     I2BIN() es BIN2I().

 Ejemplos

     .  Este ejemplo abre un fichero de base de datos utilizando
        funciónes de fichero de bajo nivel y escribe la fecha de la .ltima
        actualizaci.n en los bytes 1-3:

        #include "Fileio.ch"
        //
        nManejador = FOPEN("Ventas.dbf", FO_READWRITE)
        //
        // Convierte en un entero la fecha de la .ltima actualizaci.n
        nAnno = I2BIN(90)
        nMes = I2BIN(12)
        nDia = I2BIN(15)
        //
        // Se.ala la fecha de la .ltima actualizaci.n
        FSEEK(nManejador, 1, FS_SET)
        //
        // Escribe la fecha de la nueva actualizaci.n
        // utilizando sólo el primer byte
        FWRITE(nManejador, nAnno, 1)
        FWRITE(nManejador, nMes, 1)
        FWRITE(nManejador, nDia, 1)
        FCLOSE(nManejador)

 Ficheros:  La biblioteca asociada es EXTEND.LIB,
            el módulo fuente es SOURCE\SAMPLE\EXAMPLEA.ASM.


IF()
 Retorna el resultado de una expresión en base a una condición.
------------------------------------------------------------------------------
 Sintaxis

     [I]IF(<lCondici.n>, <expVerdadera>, <expFalsa>) --> Valor

 Argumentos

     <lCondici.n> es la expresión l.gica que se va a evaluar.

     <expVerdadera> es el valor de cualquier tipo de datos que se
     devuelve si <lCondici.n> es verdadera (.T.).

     <expFalsa> es el valor, de cualquier tipo de datos, que se devuelve
     si <lCondici.n> es falsa (.F.). No es necesario que este argumento sea
     del mismo tipo de datos que <expVerdadera>.

 Devuelve

     IF() devuelve el resultado de <expVerdadera> si <lCondici.n> resulta
     verdadera (.T.) y de <expFalsa> si resulta falsa (.F.). El valor
     devuelto es del tipo de datos de la expresión víaacute;lida.

 Descripción

     IF() es una función de conversión l.gica. Es una de las funciónes m.s
     potentes y vers.tiles de CA-Clipper. Ofrece un mecanismo para evaluar
     una condición dentro de una expresión. Con esta función puede convertir
     una expresión l.gica en otro tipo de datos.

 Ejemplos

     .  Este ejemplo convierte un valor de datos l.gico en un valor
        numérico:

        lPagado =.T.
        ? IF(lPagado, 1, 0)               // Resultado: 1

     .  En este ejemplo se da formato a un campo l.gico dependiendo de
        si ha vencido o no el per.odo de pago del cliente.

        @ ROW() + 1, 25 SAY IF(lPagado, SPACE(10), ".A por ellos!")

     .  Si imprime formularios, puede imprimir un s.mbolo indicativo
        en diferentes columnas dependiendo del valor de un campo l.gico:

        @ ROW(), IF(EnHospital, 10, 12) SAY "X"

     .  Puede utilizar también la función IF() para obligar a LABEL
        FORM a imprimir líneas en blanco. Introduzca la siguiente expresión
        cuando cree la etiqueta con RL.EXE:

        IF(EMPTY(Empresa), CHR(255), Empresa)

 Ficheros:  La biblioteca asociada es CLIPPER.LIB.


INDEXEXT()
 Devuelve la extensión por defecto de los ficheros ííndice basada en el
 controlador de base de datos actualmente enlazado
------------------------------------------------------------------------------
 Sintaxis

     INDEXEXT() --> cExtensi.n

 Devuelve

     A menos que se haya enlazado otro controlador de base de datos,
     INDEXEXT() devuelve ".NTX", lo que indica que est. activo el controlador
     por defecto de CA-Clipper. Si est. enlazado el controlador compatible
     con dBASE III PLUS, la función devuelve "NDX".

 Descripción

     INDEXEXT() devuelve la extensión por defecto del fichero ííndice, en
     función del controlador de base de datos actualmente enlazado.

 Ejemplos

     .  En este ejemplo, INDEXEXT() crea una prueba de existencia del
        fichero ííndice Cliente independiente del controlador de base de datos
        enlazado al programa actual:

        USE Cliente NEW
        //
        IF.NOT. FILE("Cliente" + INDEXEXT())
           INDEX ON NombreCliente TO Cliente
        ENDIF

 Ficheros:  La biblioteca asociada es CLIPPER.LIB.


INDEXKEY()
 Devuelve la expresión clave del índice especificado
------------------------------------------------------------------------------
 Sintaxis

     INDEXKEY(<nOrden>) --> cExpClave

 Argumentos

     <nOrden> es la posición original del índice en la lista de ficheros
     índice abierta por el último mandato USE...INDEX o SET INDEX TO en el
     área de trabajo actual. Un valor cero expecifica el índice activo,
     independientemente de su posición real en la lista.

 Devuelve

     INDEXKEY() devuelve la expresión clave del índice especificado como una
     cadena de carácteres. Si no hay índice correspondiente o no se ha
     abierto ningún fichero de base de datos, INDEXKEY() devuelve una cadena
     nula.("").

 Descripción

     INDEXKEY() es una función de base de datos que determina la expresión
     clave de un ííndice especificado en el área de trabajo actual y la
     devuelve como una cadena de carácteres. Para evaluar la expresión clave,
     especifique INDEXKEY() como una macroexpresión similar a la siguiente:
     &(INDEXKEY(<nOrden>)).

     INDEXKEY() tiene cierto número de aplicaciónes, pero dos en concreto son
     importantes. Con esta función puede totalizar la base de datos a trav.s
     de la expresión clave en el código fuente. El otro caso tiene lugar en
     la función de usuario de DBEDIT(). Aqu. puede ser necesario decidir si
     actualizar o no la pantalla después de que el usuario haya editado un
     registro. Normalmente, sólo es necesario actualizar la pantalla si ha
     cambiado la expresión clave del índice activo en el registro actual.
     Ambos ejemplos se describen m.s abajo.

     Por defecto, INDEXKEY() act.a en el área de trabajo actualmente
     seleccionada. Puede hacer que act.e en un área de trabajo no
     seleccionada especific.ndola con una expresión de alias (consulte el
     ejemplo siguiente).

 Ejemplos

     .  Este ejemplo accede a la expresión clave de los ííndices
        abiertos en el área de trabajo actual:

        #define ORD_NATURAL      0
        #define ORD_NOMBRE      1
        #define ORD_SERIE         2
        //
        USE Cliente INDEX Nombre, Serie NEW
        SET ORDER TO ORD_SERIE
        ? INDEXKEY(ORD_NOMBRE)      // Resultado: exp índice de nombres
        ? INDEXKEY(ORD_SERIE)       // Resultado: exp índice en serie
        ? INDEXKEY(ORD_NATURAL)     // Resultado: exp índice en serie

     .  Este ejemplo accede a la expresión clave del índice activo en
        un área de trabajo no seleccionada:

        USE Cliente INDEX Nombre, Serie NEW
        USE Ventas INDEX Vendedor NEW
        ? INDEXKEY(0), Cliente->(INDEXKEY(0))

     .  Este ejemplo utiliza INDEXKEY() como parte de una expresión
        TOTAL ON de clave. Observe que INDEXKEY() se especifica con una
        macroexpresión para obligar a evaluar la expresión:

        USE Ventas INDEX Vendedor NEW
        TOTAL ON &(INDEXKEY(0)) FIELDS CantidadVentas;
                                      TO ResumenVentas

     .  Este ejemplo utiliza INDEXKEY() para determinar si debe
        actualizarse la pantalla de DBEDIT() después de que el usuario haya
        editado el valor de campo actual. Normalmente, es necesario
        actualizar la pantalla DBEDIT() si el usuario cambia un campo que es
        parte de la clave del índice activo. EditarFichero() es una función
        definida por el usuario llamada desde una función DBEDIT() de usuario
        para editar el campo actual si el usuario ha pulsado una tecla de
        edici.n.

        #include "Dbedit.ch"
        #define ORD_NATURAL   0
        FUNCTION EditarFichero()
           LOCAL Valíndice
           // Guarda el valor y expresión clave actual
           Valíndice = &(INDEXKEY(ORD_NATURAL))
           .
           . <código para obtener (GET) el valor de campo actual>
           .
           // Actualizar la pantalla si ha cambiado el
           //valor clave
           IF Valíndice != &(INDEXKEY(ORD_NATURAL))
              nPeticion = DE_REFRESH
           ELSE
              nPeticion = DE_CONT
           ENDIF
           RETURN nPeticion

 Ficheros: La biblioteca asociada es CLIPPER.LIB.


INDEXORD()
 Devuelve la posición de orden del índice activo.
------------------------------------------------------------------------------
 Sintaxis

     INDEXORD() --> nOrden

 Devuelve

     INDEXORD() devuelve un valor numérico entero. El valor devuelto es igual
     a la posición del índice activo en la lista de ficheros ííndice abiertos
     del área de trabajo actual. Un valor cero indica que no hay índice
     activo y que se est. accediendo a los registros en su orden natural. Si
     no hay abierto ningún fichero de base de datos, INDEXORD() devuelve
     también el valor cero.

 Descripción

     INDEXORD() es una función de base de datos que determina la posición del
     índice activo en la lista de ficheros ííndice abiertos por el último
     mandato USE...INDEX o SET INDEX TO en el área de trabajo actual. Suele
     ser conveniente guardar el último índice de control para poder
     restablecerlo m.s tarde.

     Por defecto, INDEXORD() act.a en el área de trabajo actualmente abierta.
     Para que opere en un área de trabajo no seleccionada, debe especificarla
     como parte de una expresión de alias (consulte el ejemplo siguiente).

 Ejemplos

     .  Este ejemplo utiliza INDEXORD() para guardar el orden actual.
        Despu.s de cambiar a un nuevo orden, utiliza el valor guardado para
        restablecer el orden original:

        USE Cliente INDEX Nombre, Serie NEW
        nOrden := INDEXORD()               // Resultado: 1
        SET ORDER TO 2
        ? INDEXORD()                       // Resultado: 2
        SET ORDER TO nOrden
        ? INDEXORD()                       // Resultado: 1

     .  Este ejemplo utiliza una expresión de alias para determinar el
        número de orden del índice activo en un área de trabajo no
        seleccionada:

        USE Ventas INDEX Vendedor, NumCliente NEW
        USE Cliente INDEX Nombre, Serie NEW
        ? Ventas->(INDEXORD())             // Resultado: 1

 Ficheros:  La biblioteca asociada es CLIPPER.LIB.



INKEY()
 Lee un carácter de la memoria intermedia del teclado
------------------------------------------------------------------------------
 Sintaxis

     INKEY([<nSegundos>]) --> nC.digoInkey

 Argumentos

     <nSegundos> Especifica el número de segundos que INKEY() espera a
     que se pulse una tecla. Puede especificar valores en incrementos de
     hasta una d.cima de segundo. Si se especifica cero, el programa se
     detiene hasta que se pulse una tecla. Si se omite <nSegundos> INKEY() no
     espera a que se pulse una tecla.

 Devuelve

     INKEY() devuelve un valor numérico comprendido entre -39 y 386, que
     identifica la tecla le.da de la memoria intermedia del teclado. Si la
     memoria intermedia est. vac.a INKEY() devuelve cero. INKEY() devuelve
     valores para todas las combinaciónes de carácteres ASCII, funciónes,
     Alt-función, Ctrl-función, Alt-letra y Ctrl-letra.

 Descripción

     INKEY() es una función de teclado que lee la tecla siguiente contenida
     en la memoria intermedia del teclado y devuelve un valor que representa
     esa tecla. Este valor se guarda también internamente y puede recuperarse
     por medio de LASTKEY(). Si se especifica el argumento <nSegundos> y no
     hay teclas pendientes en la memoria intermedia, la ejecución del
     programa se detiene hasta que aparezca una tecla en la memoria del
     teclado o haya transcurrido <nSegundos>. El tiempo que espera la función
     INKEY() se basa en el reloj del sistema operativo y no en la velocidad
     del microprocesador. Si <nSegundos> es cero, la ejecución del programa
     se detiene hasta que haya alguna tecla en la memoria intermedia.
     Recuerde que INKEY() no es un estado de espera, por lo que las teclas
     establecidas mediante SET KEY no están activas.

     INKEY() es similar a la función NEXTKEY(). A diferencia de INKEY(),
     NEXTKEY() lee sin extraer la tecla de la memoria intermedia del teclado.
     Esto es útil para comprobar la existencia de una tecla sin procesarla.

     INKEY() es la primitiva principal del sistema de CA-Clipper para extraer
     teclas de la memoria intermedia del teclado. Se utiliza para sondear el
     teclado o hacer una pausa en la ejecución del programa hasta que se
     pulse una tecla. Como ejemplo, puede utilizar INKEY() para terminar
     mandatos con un ámbito de lectura como LIST, LABEL FORM y REPORT FORM
     incluyendo una condición WHILE. Consulte el ejemplo siguiente.

     Si desea una lista completa de los códigos INKEY() y constantes de
     Inkey.ch, consulte la gu.a de Mensajes de Error y Apííndices.

 Ejemplos

     .  Este ejemplo recoge una tecla del teclado y muestra el valor
        de su carácter seguido por el valor de INKEY():

        #include "Inkey.ch"
        //
        LOCAL nCodigoInkey := 0
        DO WHILE LASTKEY() != K_ESC
           ? "Pulse una tecla: "
           nCodigoInkey := INKEY(0)
           ?? "Car.cter:", CHR(nCodigoInkey),;
              "C.digo INKEY():", LTRIM(STR(nCodigoInkey))
        ENDDO
        RETURN

     .  Este ejemplo utiliza INKEY() para sondear la pulsaci.n de una
        tecla de interrupci.n durante un REPORT FORM. Si el usuario pulsa Esc
        durante el proceso de impresión, el proceso REPORT FORM termina:

        #include "Inkey.ch"
        //
        USE Ventas INDEX Vendedor NEW
        REPORT FORM MONTHLY FOR MONTH(FechaVentas) = ;
              MONTH(DATE());
           WHILE INKEY() != K_ESC

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


INT()
 Convierte un valor numérico en un número entero
------------------------------------------------------------------------------
 Sintaxis

     INT(<nExp>) --> nEntero

 Argumentos

     <nExp> es la expresión numérica que se va a convertir en entero.

 Devuelve

     INT() devuelve un valor numérico entero.

 Descripción

     INT() es una función numérica que convierte un valor numérico en un
     entero truncando (sin redondear) todos los dígitos situados a la derecha
     de la coma decimal. INT() es útil en operación.s en las que no es
     necesaria la parte decimal de un número.

 Ejemplos

     .  Estos ejemplos muestran los resultados de varias llamadas a la
        función INT():

        ? INT(100.00)                // Resultado: 100
        ? INT(.5)                    // Resultado: 0
        ? INT(-100.75)               // Resultado: -100

 Ficheros:  La biblioteca asociada es CLIPPER.LIB.


ISALPHA()
 Determina si el carácter inicial de una cadena de carácteres es alfabético
------------------------------------------------------------------------------
 Sintaxis

     ISALPHA(<cCadena>) --> lBooleano

 Argumentos

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

 Devuelve

     ISALPHA() devuelve verdadero (.T.) si el primer carácter de <cCadena> es
     alfabético; en caso contrario devuelve falso (.F.).

 Descripción

     ISALPHA() es una función de carácteres que determina si la cadena
     especificada comienza con un carácter alfabético. Se consideran
     carácteres alfabéticos todas las letras mayúsculas o minúsculas de la A
     a la Z. ISALPHA() devuelve falso (.F.) si la cadena comienza con un
     dígito o con cualquier otro carácter.

 Ejemplos

     .  Estos ejemplos muestran varios resultados de ISALPHA():

        ? ISALPHA("AbcDe")               // Resultado:.T.
        ? ISALPHA("aBcDE")               // Resultado:.T.
        ? ISALPHA("1BCde")               // Resultado:.F.
        ? ISALPHA(".FRED")               // Resultado:.F.

 Ficheros:  La biblioteca asociada es EXTEND.LIB.


ISCOLOR()
 Determina si el ordenador actual soporta color
------------------------------------------------------------------------------
 Sintaxis

     ISCOLOR() | ISCOLOUR() --> lBooleano

 Devuelve

     ISCOLOR() devuelve verdadero (.T.) si hay una tarjeta gr.fica de color
     instalada; en caso contrario devuelve falso (.F.).

 Descripción

     ISCOLOR() es una función de pantalla que se puede utilizar para decidir
     el tipo de atributos de pantalla (color o monocromo). Recuerde que
     algunos adaptadores monocromos con capacidades gr.ficas devuelven
     verdadero (.T.).

 Ejemplos

     .  Este ejemplo instala variables de atributo de color durante la
        ejecución:

     IF ISCOLOR()

           cBox = "BG+/B, W/N"
           cSays = "BG/B, W/N"
           cGets = "W/N, N/W"
        ELSE
           cBox = "W+"
           cSays = "W/N, N+/W"
           cGets = "W/N, N/W"
        ENDIF
        .
        . <sentencias>
        .
        SETCOLOR(cSays)

 Ficheros:  La biblioteca asociada es CLIPPER.LIB.


ISDIGIT()
 Determina si el carácter inicial de una cadena de carácteres es un dígito
------------------------------------------------------------------------------
 Sintaxis

     ISDIGIT(<cCadena>) --> lBooleano

 Argumentos

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

 Devuelve

     ISDIGIT() devuelve verdadero (.T.) si el primer carácter de una cadena
     es un dígito comprendido entre cero y nueve; en caso contrario devuelve
     falso (.F.).

 Descripción

     ISDIGIT() es una función de carácteres que determina si el primer
     carácter de una cadena es un dígito del cero al nueve. Si el primer
     carácter de <cCadena> es de cualquier otro tipo, ISDIGIT() devuelve
     falso (.F.).

     ISDIGIT() es útil para determinar si la cadena actual es un número antes
     de convertirla en un valor numérico por medio de la función VAL().

 Ejemplos

     .  Estos ejemplos muestra diferentes resultados de ISDIGIT():

        ? ISDIGIT("AbcDe")          // Resultado:.F.
        ? ISDIGIT("1abcd")          // Resultado:.T.
        ? ISDIGIT(".12345")         // Resultado:.F.

 Ficheros:  La biblioteca asociada es EXTEND.LIB.


ISLOWER()
 Determina si el carácter inicial de una cadena de carácteres es una letra
 minúscula
------------------------------------------------------------------------------
 Sintaxis

     ISLOWER(<cCadena>) --> lBooleano

 Argumentos

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

 Devuelve

     ISLOWER() devuelve verdadero (.T.) si el primer carácter de una cadena
     es una letra minúscula; es caso contrario devuelve falso (.F.).

 Descripción

     ISLOWER() es una función de carácteres que determina si el primer
     carácter de una cadena de carácteres es una letra minúscula. Es la
     función inversa de ISUPPER(), que determina si el primer carácter es una
     letra mayúscula.

     ISLOWER() y ISUPPER() están relacionadas con las funciónes LOWER() y
     UPPER(), que convierten las letras mayúsculas en minúsculas y viceversa.

 Ejemplos

     .  Estos ejemplos muestran diferentes resultados de ISLOWER():

        ? ISLOWER("aBcDe")         // Resultado:.T.
        ? ISLOWER("AbcDe")         // Resultado:.F.
        ? ISLOWER("1abcd")         // Resultado:.F.
        ? ISLOWER("abcd")          // Resultado:.T.

 Ficheros:  La biblioteca asociada es CLIPPER.LIB.



ISPRINTER()
 Determina si el puerto LPT1 est. preparado.
------------------------------------------------------------------------------
 Sintaxis

     ISPRINTER() --> lPreparado

 Devuelve

     ISPRINTER() devuelve verdadero (.T.) si el puerto LPT1 est. preparado;
     en caso contrario devuelve falso (.F.).

 Descripción

     ISPRINTER() es una función de impresora que determina si el puerto
     paralelo LPT1 est. en línea y preparado para imprimir. ISPRINTER() es
     una función dependiente del hardware, por lo que sólo act.a en sistemas
     cuyo BIOS es compatible con IBM.

     Puede comprobar ISPRINTER() para asegurarse de que la impresora est.
     lista antes de empezar a imprimir. No obstante, si se produce un error
     durante la impresi.n, se genera un error de ejecución.

 Ejemplos

     .  Este ejemplo comprueba si est. preparado el puerto paralelo,
        realizando hasta 25 reintentos. Si el puerto paralelo est. preparado,
        se inicia la operación.de impresión:

        LOCAL nCuenta := 0, nVeces := 25, lPrep
        //
        DO WHILE nCuenta++ <= nVeces.AND. !(lPrep := ;
              ISPRINTER())
        ENDDO
        //
        IF lPrep
           REPORT FORM Ventas TO PRINTER
        ELSE
           ? "La impresora no est. preparada..."
           BREAK
        ENDIF

 Ficheros:  La biblioteca asociada es EXTEND.LIB,
            el módulo fuente es SOURCE\SAMPLE\EXAMPLEA.ASM.



ISUPPER()
 Determina si el carácter inicial de una cadena de carácteres es una letra
 mayúscula
------------------------------------------------------------------------------
 Sintaxis

     ISUPPER(<cCadena>) --> lBooleano

 Argumentos

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

 Devuelve

     ISUPPER() devuelve verdadero (.T.) si el primer carácter es una letra
     mayúscula; en caso contrario devuelve falso (.F.).

 Descripción

     ISUPPER() es una función de carácteres que determina si el primer
     carácter de una cadena es una letra mayúscula. Es la función inversa de
     ISLOWER(). ISUPPER() e ISLOWER() están relacionadas con las funciónes
     UPPER() y LOWER() que convierten letras minúsculas en mayúsculas y
     viceversa.

 Ejemplos

     .  Este ejemplo ilustra ISUPPER() aplicada a diferentes valores:

        ? ISUPPER("AbCdE")         // Resultado:.T.
        ? ISUPPER("aBCdE")         // Resultado:.F.
        ? ISUPPER("$abcd")         // Resultado:.F.
        ? ISUPPER("8ABCD")         // Resultado:.F.

 Ficheros:  La biblioteca asociada es CLIPPER.LIB.



L2BIN()
 Convierte un valor numérico de CA-Clipper en un valor entero binario de 32
 bits
------------------------------------------------------------------------------
 Sintaxis

     L2BIN(<nExp>) --> cEnteroBinario

 Argumentos

     <nExp>es el valor numérico que se va a convertir. Los números
     decimales se truncan.

 Devuelve

     L2BIN() devuelve una cadena de carácteres de 4 bytes formateada como un
     entero binario de 32 bits.

 Descripción

     L2BIN() es una función de bajo nivel que se utiliza con FWRITE() para
     escribir valores numéricos de CA-Clipper en un fichero binario. Esta
     función es similar a I2BIN(), que formatea un valor numérico de
     CA-Clipper en un valor binario de 16 bits.

     L2BIN() es la función inversa de BIN2L().

 Ejemplos

     .  Este ejemplo crea un nuevo fichero binario y escribe una serie
        de números en los ficheros utilizando L2BIN() para convertir el valor
        numérico en un número binario de 32 bits:

        #include "Fileio.ch"
        //
        LOCAL nNúmero, nManejador
        nManejador := FCREATE("Fichero", FC_NORMAL)
        FOR nNúmero := 1 TO 100
           FWRITE(nManejador, L2BIN(nNúmero) + CHR(0))
        NEXT
        FCLOSE(nManejador)

 Ficheros:  La biblioteca asociada es EXTEND.LIB,
            el módulo fuente es SOURCE\SAMPLE\EXAMPLEA.ASM.



LASTKEY()
 Devuelve el valor INKEY() de la .ltima tecla extra.da de la memoria
 intermedia del teclado
------------------------------------------------------------------------------
 Sintaxis

     LASTKEY() --> nC.digoInkey

 Devuelve

     LASTKEY() devuelve un número entre -39 y 386, que identifica el valor
     INKEY() de la .ltima tecla extra.da de la memoria intermedia del
     teclado.

 Descripción

     LASTKEY() es una función de teclado que informa del valor INKEY() de la
     .ltima tecla recogida de la memoria intermedia del teclado por la
     función INKEY() o por un estado de espera como ACCEPT, INPUT, READ,
     WAIT, ACHOICE(), DBEDIT() o MEMOEDIT(). LASTKEY() conserva su valor
     actual hasta que se recoge otra tecla de la memoria intermedia del
     teclado.

     LASTKEY() permite:

     .  Determinar la tecla que termina un READ.

     .  Determinar la tecla que provoca la salida del objeto GET
        actual en una función definida por el usuario, invocada por una
        cláusula VALID.

     .  Identificar una tecla de excepci.n en la función de usuario de
        ACHOICE(), DBEDIT() o MEMOEDIT().

     LASTKEY() se utiliza también con la función UPDATED() para determinar si
     se ha modificado la memoria intermedia de alg.n objeto Get durante un
     READ.

     LASTKEY() se relaciona con NEXTKEY() y READKEY(). NEXTKEY() lee la tecla
     actual pendiente en la memoria intermedia del teclado sin eliminarla de
     la misma. Utilice NEXTKEY() en vez de INKEY() cuando desee consultar una
     tecla.

     Si desea una lista completa de los códigos de INKEY() y constantes de
     INKEY.CH para cada tecla, consulte la gu.a Mensajes de Error y
     Apííndices.

 Ejemplos

     .  Este ejemplo muestra una aplicación t.pica de LASTKEY() para
        comprobar la tecla con la que se sale de un READ. Si el usuario sale
        con una tecla distinta de Esc y se ha modificado el objeto Get, se
        actualiza el fichero especificado de base de datos.

     #include "Inkey.ch"
        //
        USE Cliente NEW
        MEMVAR->balance = Cliente->Balance

        @ 10, 10 SAY "Balance Actual" GET MEMVAR->balance
        READ
        //
        IF (LASTKEY() != K_ESC).AND. UPDATED()
           REPLACE Cliente->Balance WITH MEMVAR->balance
        ENDIF

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


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

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

 Devuelve

     LASTREC() devuelve el número de registros f.sicos en el fichero actual
     de base de datos, en forma de valor numérico entero. Los mandatos de
     filtrado como SET FILTER o SET DELETED no tienen efecto sobre el valor
     devuelto. LASTREC() devuelve cero si no hay ningún fichero de base de
     datos utilizado en el área de trabajo actual.

 Descripción

     LASTREC() es una función de base de datos que determina el número de
     registros f.sicos existentes en el fichero actual de base de datos.
     LASTREC() es id.ntica a RECCOUNT(), que se incluye por razones de
     compatibilidad.

     Por defecto, LASTREC() act.a en el área de trabajo actualmente
     seleccionada. Para que opere sobre un área de trabajo no seleccionada,
     debe especificarse como parte de una expresión de alias (consulte el
     ejemplo siguiente).

 Ejemplos

     .  Este ejemplo muestra la relaci.n entre LASTREC(), RECCOUNT() y
        COUNT:

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

     .  Este ejemplo utiliza una expresión de alias para acceder al
        número de registros de un fichero de base de datos abierto en un .rea
        de trabajo no seleccionada.

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

 Ficheros:  La biblioteca asociada es CLIPPER.LIB.



LEFT()
 Extrae una subcadena comenzando en el primer carácter de una cadena
------------------------------------------------------------------------------
 Sintaxis

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

 Argumentos

     <cCadena> es la cadena de la que se extraen los carácteres. El
     tama.o máximo de <cCadena> es de 65.553 (64K) bytes.

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

 Devuelve

     LEFT() devuelve los <nPosiciones> carácteres m.s a la izquierda de
     <cCadena>, como una cadena de carácteres. Si <nPosiciones> es cero o
     negativo, LEFT() devuelve una cadena nula (""). Si <nPosiciones> es
     mayor que la longitud de la cadena de carácteres, LEFT() devuelve toda
     la cadena.

 Descripción

     LEFT() es una función de carácteres que devuelve una subcadena de la
     cadena de carácteres especificada. Es id.ntica a
     SUBSTR(<cCadena>,1,<nPosiciones>). LEFT() es similar a RIGHT(), que
     devuelve una subcadena comenzando por el último carácter de la misma.

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

 Ejemplos

     .  Este mandato extrae los tres primeros carácteres empezando por
        la izquierda de la cadena:

        ? LEFT("ABCDEF", 3)                        // Resultado: ABC

     .  Este ejemplo extrae una subcadena comenzando por el principio
        de otra cadena, hasta la primera coma:

        LOCAL cNombre := "Jorge, Luis"
        ? LEFT(cNombre, AT(",", cNombre) - 1)      // Resultado:
                                                   // Jorge

 Ficheros:  La biblioteca asociada es CLIPPER.LIB.


LEN()
 Devuelve la longitud de una cadena de carácteres o el número de elementos de
 una matriz
------------------------------------------------------------------------------
 Sintaxis

     LEN(<cCadena> | <aDestáno>) --> nPosiciones

 Argumentos

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

     <aDestáno> es la matriz que se va a contar.

 Devuelve

     LEN() devuelve la longitud de una cadena de carácteres o el número de
     elementos en una matriz, como un número entero. Si la cadena de
     carácteres es una cadena nula ("") o la matriz est. vac.a, LEN()
     devuelve cero.

 Descripción

     LEN() es una función de carácteres y matrices que devuelve la longitud
     de una cadena de carácteres o el número de elementos en una matriz. Con
     una cadena de carácteres, cada byte se cuenta como uno, incluyendo un
     byte nulo (CHR (0)). Por contra, una cadena nula ("") se cuenta como
     cero.

     Para una matriz, LEN() devuelve el número de elementos. Si la matriz es
     multidimensiónal, las submatrices se cuentan como un elemento. Esto
     quiere decir que el valor devuelto por LEN() para una matriz anidada o
     multidimensiónal es simplemente la longitud de la primera dimensión.
     Para determinar el número de elementos en otras dimensiónes, utilice
     LEN() en las submatrices como se muestra en el ejemplo siguiente.
     Recuerde que las matrices anidadas en CA-Clipper no necesitan tener
     dimensiónes uniformes.

 Ejemplos

     .  Estos ejemplos muestran la utilización de LEN() con varios
        argumentos:

        ? LEN("cadena de carácteres")          // Resultado: 20
        ? LEN("")                              // Resultado: 0
        ? LEN(CHR(0))                          // Resultado: 1
        //
        LOCAL aPrueba[10]
        ? LEN(aPrueba)                         // Resultado: 10

     .  Este ejemplo crea una matriz bidimensiónal de forma literal y
        devuelve el número de elementos en la submatriz contenida en el
        primer elemento de la matriz original:

        LOCAL aMatriz := { {1, 2}, {1, 2}, {1, 2} }
        ? LEN(aMatriz)                         // Resultado: 3
        ? LEN(aMatriz[1])                      // Resultado: 2

     .  Este ejemplo se desplaza por una matriz multidimensiónal
        utilizando LEN():

        LOCAL aMatriz := { {1, 2}, {1, 2}, {1, 2} }
        LOCAL nFilas, nCols, nPosFilas, nPosCols
        //
        nPosFilas = LEN(aMatriz)
        FOR nFilas = 1 TO nPosFilas
           nPosCols = LEN(aMatriz[nFilas])
           FOR nCols = 1 TO nPosCols
              ? nFilas, nCols, aMatriz[nFilas][nCols]
           NEXT
        NEXT

     .  En este ejemplo, una función devuelve una matriz de valores
        numéricos que describe las dimensiónes de una matriz multidimensiónal
        anidada. La función supone que la matriz tiene dimensiónes uniformes:

        FUNCTION Dimensiones( aMatriz )
           LOCAL aDims := {}
           DO WHILE ( VALTYPE(aMatriz) == "A" )
              AADD( aDims, LEN(aMatriz) )
              aMatriz := aMatriz[1]
           ENDDO
           RETURN (aDims)

 Ficheros: La biblioteca asociada es CLIPPER.LIB.



LOG()
 Calcula el logaritmo natural de un valor numérico
------------------------------------------------------------------------------
 Sintaxis

     LOG(<nExp>) --> nLogNatural

 Argumentos

     <nExp> es el valor numérico mayor que cero que desea convertir en su
     logaritmo natural.

 Devuelve

     LOG() devuelve el logaritmo natural como un valor numérico. Si <nExp> es
     menor o igual a cero, LOG() devuelve un error de desbordamiento numérico
     (mostrado como una fila de asteriscos).

 Descripción

     LOG() es una función numérica que calcula el logaritmo natural de un
     número. Es la inversa de EXP(). Losólogaritmos naturales tienen como
     base el número e, que es igual a 2.7183 aproximadamente. La función
     LOG() devuelve x en la siguiente ecuaci.n:

     e**x = y

     donde y es la expresión numérica utilizada como argumento de LOG() (es
     decir, LOG(y) = x). Debido al redondeo matem.tico, los valores devueltos
     por LOG() y EXP() pueden no corresponderse exactamente (es decir,
     EXP(LOG(x)) puede no ser siempre igual a x).

 Ejemplos

     .  Estos ejemplos muestran los resultados de diversos usos de
        LOG():

        ? LOG(10)                      // Resultado: 2.30
        ? LOG(10 * 2)                  // Resultado: 3.00
        ? EXP(LOG(1))                  // Resultado: 1.00
        ? LOG(2.71)                    // Resultado: 1.00

     .  Este ejemplo es una función definida por el usuario que
        devuelve el logaritmo en base 10:

        FUNCTION Log10( nNúmero )
        IF nNúmero > 0
           RETURN LOG(nNúmero)/LOG(10)
        ELSE
           RETURN NIL
        ENDIF

 Ficheros:  La biblioteca asociada es CLIPPER.LIB.



LOWER()
 Convierte en minúsculasólos carácteres en mayúsculas
------------------------------------------------------------------------------
 Sintaxis

     LOWER(<cCadena>) --> cCadenaMin.sc

 Argumentos

     <cCadena> es la cadena de carácteres que desea convertir en
     minúsculas.

 Devuelve

     LOWER() devuelve una copia de <cCadena> con todos los carácteres
     alfabéticos en letras minúsculas. Los restántes carácteres permanecen
     inalterados en la cadena original.

 Descripción

     LOWER() es una función de carácteres que convierte cadenas en mayúsculas
     y mixtas en cadenas en minúsculas. Está relacionada con UPPER() que
     convierte cadenas en minúsculas y mixtas en cadenas en mayúsculas.
     LOWER() está relacionada con las funciónes ISLOWER() e ISUPPER() que
     determinan si una cadena comienza con un carácter en minúscula o
     mayúscula.

     LOWER() se utiliza normalmente para formatear una cadena de carácteres
     para su visualización en pantalla. Puede utilizarse también para
     normalizar cadenas en comparaciones que no diferencian mayúsculas y
     minúsculas o para la indexación con INDEX.

 Ejemplos

     .  Estos ejemplos muestran los resultados de diferentes usos de
        LOWER():

        ? LOWER("CADENA")                // Resultado: cadena
        ? LOWER("1234 CARACTERES = ")    // Resultado: 1234 carácteres =

 Ficheros:  La biblioteca asociada es CLIPPER.LIB.


LTRIM()
 Elimina los espacios en blanco iniciales de una cadena de carácteres
------------------------------------------------------------------------------
 Sintaxis

     LTRIM(<cCadena>) --> cCadenaRecortada

 Argumentos

     <cCadena> es la cadena de carácteres de la que desea eliminar los
     espacios iniciales en blanco.

 Devuelve

     LTRIM() devuelve una copia de <cCadena> sin los espacios iniciales en
     blanco. Si <cCadena> es una cadena nula ("") o est. formada por
     espacios, LTRIM() devuelve una cadena nula ("").

 Descripción

     LTRIM() es una función de carácteres que formatea cadenas de carácteres
     con espacios iniciales en blanco. Estas pueden ser, por ejemplo, números
     que se convierten en una cadena de carácteres útilizando STR().

     LTRIM() está relacionada con RTRIM(), que elimina los espacios en blanco
     finales, y con ALLTRIM(), que elimina los espacios en blanco tanto
     iniciales como finales. Las funciónes inversas de ALLTRIM(), LTRIM() y
     RTRIM() son PADC(), PADR() y PADL() que centran, justifican a la derecha
     o a la izquierda, respectivamente, la cadena de carácteres a.adiendo
     carácteres de relleno.

 Ejemplos

     .  Estos ejemplos muestran los resultados de diferentes usos de
        la función LTRIM():

        nNúmero = 18
        ? STR(nNúmero)                   // Resultado: 18
        ? LEN(STR(nNúmero))              // Resultado: 10
        ? LTRIM(STR(nNúmero))            // Resultado: 18
        ? LEN(LTRIM(STR(nNúmero)))       // Resultado:  2

 Ficheros:  La biblioteca asociada es CLIPPER.LIB.


LUPDATE()
 Devuelve la fecha de la .ltima modificaci.n de un fichero (.dbf)
------------------------------------------------------------------------------
 Sintaxis

     LUPDATE() --> fModificaci.n

 Devuelve

     LUPDATE() devuelve la fecha del último cambio realizado en el fichero de
     base de datos abierto en al área de trabajo actual. Si no se est.
     utilizando ningún fichero de base de datos, LUPDATE() devuelve una fecha
     en blanco.

 Descripción

     LUPDATE() es una función de base de datos que determina la fecha en la
     que modific. y cerr. mediante CLOSE por .ltima vez el fichero de base de
     datos del área de trabajo actual. Por defecto, LUPDATE() act.a en el
     área de trabajo actualmente seleccionada. Para que opere en un .rea de
     trabajo no seleccionada, debe especificarse en una expresión de alias,
     como se muestra en un ejemplo posterior.

 Ejemplos

     .  Este ejemplo muestra que la fecha de modificaci.n de un
        fichero de base de datos no cambia hasta que se cierra el fichero:

     ? DATE()                     // Resultado: 09/01/90
        USE Ventas NEW
        ? LUPDATE()               // Resultado: 08/31/90
        //
        APPEND BLANK

        ? LUPDATE()               // Resultado: 08/31/90
        CLOSE DATABASES
        //
        USE Ventas NEW
        ? LUPDATE()               // Resultado: 09/01/90

     .  Este ejemplo utiliza una expresión de alias para acceder a un
        fichero de base de datos abierto en un área de trabajo no
        seleccionada:

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

 Ficheros:  La biblioteca asociada es EXTEND.LIB.

Solo personas registradas pueden poner comentarios