BIN2I()
 Convierte un entero con signo de 16 bits en un valor numérico
------------------------------------------------------------------------------
 Sintaxis

     BIN2I(<cEntConSigno>) --> nNúmero

 Argumentos

     <cEntConSigno> es una cadena de carácteres en formato de entero con
     signo de 16 bits (el byte menos significativo primero). La función sólo
     utiliza los dos primeros carácteres; todos los dem.s se ignoran.

 Devuelve

     BIN2I() devuelve un valor numérico entero.

 Descripción

     BIN2I() es una función de ficheros de bajo nivel que se utiliza con
     FREAD() para convertir una cadena de carácteres de dos bytes, en formato
     de entero con signo, en datos numéricos de CA-Clipper. Es muy .til al
     leer ficheros de otros productos, porque permite leer los datos
     numéricos en su formato nativo.

 Ejemplos

     .  Este ejemplo abre un fichero de base de datos utilizando
        funciónes de fichero de bajo nivel y lee la fecha de la .ltima
        actualizaci.n (bytes 1-3). El resultado es el mismo que con
        LUPDATE():

        #include "Fileio.ch"
        //
        nManejador := FOPEN("Ventas.dbf", FO_READ)
        //
        // Apuntar al byte 1 del fichero
        FSEEK(nManejador, 1, FS_SET)
        //
        // Leer la fecha de la .ltima actualizaci.n
        nAno := BIN2I(FREADSTR(nManejador, 1) + CHR(0))
        nMes := BIN2I(FREADSTR(nManejador, 1) + CHR(0))
        nDia := BIN2I(FREADSTR(nManejador, 1) + CHR(0))
        //
        ? LTRIM(STR(nMes)), LTRIM(STR(nDia)), LTRIM(STR(nAno))
        FCLOSE(nManejador)

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


BIN2L()
 Convierte un entero con signo de 32 bits en un valor numérico
------------------------------------------------------------------------------
 Sintaxis

     BIN2L(<cEntConSigno>) --> nNúmero

 Argumentos

     <cEntConSigno> es una cadena de carácteres en formato de entero con
     signo de 32 bits (el byte menos significativo primero). La función sólo
     utiliza los cuatro primeros carácteres; todos los dem.s se ignoran.

 Devuelve

     BIN2L() devuelve un valor numérico entero.

 Descripción

     BIN2L() es una función de ficheros de bajo nivel que se utiliza con
     FREAD() para convertir una cadena de carácteres de cuatro bytes, en
     formato de entero con signo, en datos numéricos de CA-Clipper. Es muy
     .til al leer ficheros de otros productos, porque permite leer los datos
     numéricos en su formato nativo.

 Ejemplos

     .  Este ejemplo abre un fichero de base de datos utilizando
        funciónes de fichero de bajo nivel y lee el número de registros
        (bytes 4-7). El resultado es el mismo que con LASTREC():

        #include "Fileio.ch"
        //
        nManejador := FOPEN("Ventas.dbf", FO_READ)
        // Nota: Ventas.dbf contiene 84 registros
        //
        // Apuntar al byte 4
        FSEEK(nManejador, 4, FS_SET)
        //
        // Leer el número de registros
        cRegistros := SPACE(4)
        FREAD(nManejador, @cRegistros, 4)
        //
        ? LTRIM(STR(BIN2L(cRegistros)))         // Resultado: 84
        FCLOSE(nManejador)

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


BIN2W()
 Convierte un entero sin signo de 16 bits en un valor numérico
------------------------------------------------------------------------------
 Sintaxis

     BIN2W(<cEntSinSigno>) --> nNúmero

 Argumentos

     <cEntSinSigno> es una cadena de carácteres en formato de entero sin
     signo de 16 bits (el byte menos significativo primero). La función sólo
     utiliza los dos primeros carácteres; todos los dem.s se ignoran.

 Devuelve

     BIN2W() devuelve un valor numérico entero.

 Descripción

     BIN2W() es una función de ficheros de bajo nivel que se utiliza con
     FREAD() para convertir una cadena de carácteres de dos bytes, en formato
     de entero sin signo, en datos numéricos de CA-Clipper. Es muy .til al
     leer un fichero binario, porque permite leer los datos en su formato
     nativo.

 Ejemplos

     .  Este ejemplo abre un fichero de base de datos utilizando
        funciónes de fichero de bajo nivel y lee el número de bytes por
        registro (bytes 10-11). El resultado es el mismo que con RECSIZE():

        #include "Fileio.ch"
        //
        nManejador := FOPEN("Ventas.dbf", FO_READ)
        // Nota: La longitud de un registro de Ventas.dbf es 124
        //
        // Apuntar al byte 10, el byte de tama.o del primer registro
        FSEEK(nManejador, 10, FS_SET)
        //
        // Leer el tama.o de registro
        cTamReg := SPACE(2)
        FREAD(nManejador, @cTamReg, 2)
        //
        ? LTRIM(STR(BIN2W(cTamReg)))            // Resultado: 124
        FCLOSE(nManejador)

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


BOF()
 Determina si se ha encontrado o no el inicio del fichero
------------------------------------------------------------------------------
 Sintaxis

     BOF() --> lL.mite

 Devuelve

     BOF() devuelve verdadero (.T.) si se ha intentado saltar antes del
     primer registro l.gico de un fichero; en caso contrario, devuelve falso
     (.F.). Si no hay un fichero de base de datos abierto en el .rea de
     trabajo actual, BOF() devuelve falso (.F.). Si el fichero de base de
     datos actual no contiene registros, BOF() devuelve verdadero (.T.).

 Descripción

     BOF() es una función de base de datos que sirve para comprobar una
     condición de l.mite cuando el usuario desplaza el puntero de registro
     por el fichero utilizando el mandato SKIP. Un ejemplo sencillo de
     utilización ser.a una lista de registros en orden descendente que
     tuviera un fichero de índice en orden ascendente. Un ejemplo m.s
     complejo ser.a una rutina que desplazara p.ginas, en el fichero actual,
     hacia delante o hacia atr.s seg.n la tecla que el usuario hubiera
     pulsado. Al desplazarse hacia atr.s, es necesario utilizar BOF() para
     comprobar la condición de principio de fichero antes de utilizar el
     mandato SKIP para desplazar el puntero de registro y redibujar la
     pantalla.

     Una vez que BOF() toma el valor verdadero (.T.), mantiene este valor
     hasta que se realice otro intento de desplazar el puntero de registro.

     Por defecto, BOF() opera en el área de trabajo seleccionada. Para
     utilizarla en un área de trabajo no seleccionada, es necesario
     especificarla con una expresión de alias (consulte el ejemplo
     siguiente).

     El mandato SKIP es el .nico mandato de movimiento de registros que puede
     hacer que BOF() tome el valor verdadero (.T.).

 Ejemplos

     .  Este ejemplo utiliza la función BOF() intentando desplazar el
        cursor antes del primer registro:

        USE Ventas NEW
        ? RECNO(), BOF()               // Resultado: 1 .F.
        SKIP -1
        ? RECNO(), BOF()               // Resultado: 1 .T.

     .  El ejemplo siguiente utiliza expresiónes de alias para
        comprobar el valor de BOF() en .reas de trabajo no seleccionadas:

        USE Ventas NEW
        USE Cliente NEW
        USE Facturas NEW
        ? Ventas->(BOF()), Cliente->(BOF())

 Ficheros:  La biblioteca asociada es CLIPPER.LIB.


BREAK()
 Interrumpe la ejecución de una estructura BEGIN SEQUENCE...END
------------------------------------------------------------------------------
 Sintaxis

     BREAK(<exp>) --> NIL

 Argumentos

     <exp> es el valor pasado a la cláusula RECOVER, si se utiliza.
     Recuerde que <exp> no es opciónal. Puede especificarse NIL si no se
     especifica un valor de interrupci.n.

 Devuelve

     BREAK() siempre devuelve NIL.

 Descripción

     La función BREAK() es id.ntica en su funciónamiento a la sentencia
     BREAK. Esta función debe ejecutarse dentro de una estructura SEQUENCE.

 Ejemplos

     .  Este ejemplo ilustra una salida de SEQUENCE desde un bloque de
        código:

        bGuardar := ERRORBLOCK( {|x| BREAK(x)} )

        BEGIN SEQUENCE
           .
           .
           .
        RECOVER USING objError
           .
           .
           .
        END

        ERRORBLOCK(bGuardar)

 Ficheros:  La biblioteca asociada es CLIPPER.LIB.


BROWSE()*
 Visualiza registros en una ventana
------------------------------------------------------------------------------
 Sintaxis

     BROWSE([<nSup>], [<nIzq>],
        [<nInf>], [<nDer>]) --> lExito

 Argumentos

     <nSup>, <nIzq>, <nInf> y <nDer> definen las coordenadas
     de las esquinas superior izquierda e inferior derecha de la ventana. Si
     no se especifican, las coordenadas de ventana por defecto son 1, 0 y
     MAXROW(), MAXCOL().

 Devuelve

     BROWSE() devuelve falso (.F.) si no se est. utilizando ningún fichero de
     base de datos; en caso contrario devuelve verdadero (.T.).

 Descripción

     BROWSE() es una función de interfaz de usuario que invoca, en el .rea de
     trabajo actual, un programa de uso general de visualización y edici.n de
     registros en formato de tabla. Si desea una lista de las teclas de
     desplazamiento utilizadas con BROWSE(), consulte la función DBEDIT().

 Notas

     .  L.nea de estado: BROWSE() muestra una línea de estado en
        la esquina superior derecha de la ventana, que puede indicar lo
        siguiente:

        Mensajes de la L.nea de Estado de BROWSE()
        ---------------------------------------------------------------------
        Mensaje     Significado
        ---------------------------------------------------------------------
        <new>       Modo de adici.n
        <bof>       Inicio de fichero
        <delete>    Se borra el registro actual
        Registro    Visualiza el número de registro
        ---------------------------------------------------------------------

          BROWSE() posee estos tres modos:

        -  visualización: Este es el modo por defecto de BROWSE(). Al
           pulsar cualquier tecla de desplazamiento de DBEDIT(), la zona
           resaltada se desplaza a una nueva fila o columna.

        -  Edici.n de campos: Al pulsar Intro en cualquier campo se
           inicia el modo de edici.n mediante el sistema de GET. Al pulsar
           Intro de nuevo, finaliza el modo de edici.n y se guardan los
           cambios realizados. La tecla Esc finaliza la edici.n sin guardar
           los cambios. Como en el modo de edici.n de campos se utiliza el
           sistema de GET, todas las teclas de desplazamiento y de edici.n
           son las teclas que se usan en el READ.

        -  Adici.n: Si se va al final del fichero con Ctrl-AvP.g y se
           pulsa Abajo, se inicia el modo de adici.n. Aparece el mensaje
           "<new>" en la línea de estado y se inserta un nuevo registro en
           blanco. Al pulsar Arriba finaliza el modo de adici.n y se guarda
           el nuevo registro si se han introducido datos. Si no se han
           introducido datos, no se guarda dicho registro.

     .  Este es un ejemplo de visualización de un fichero:

        USE Fichero1 NEW
        BROWSE()

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



CDOW()
 Convierte un valor de fecha en un día de la semana en formato de cadena de
 carácteres
------------------------------------------------------------------------------
 Sintaxis

     CDOW(<dExp>) --> cNombreD.a

 Argumentos

     <dExp> es el valor de fecha que se va a convertir.

 Devuelve

     CDOW() devuelve el nombre del día de la semana en forma de cadena de
     carácteres. La primera letra está en mayúscula y el resto de la cadena
     en minúsculas. Si el valor de fecha es nulo, CDOW() devuelve una cadena
     nula ("").

 Descripción

     CDOW() es una función de conversión que se utiliza para dar formato a la
     visualización de fechas en informes, etiquetas y pantallas.

 Ejemplos

     .  Los ejemplos siguientes ilustran CDOW():

        ? DATE()                        // Resultado: 09/01/90
        ? CDOW(DATE())                  // Resultado: Viernes
        ? CDOW(DATE() + 7)              // Resultado: Viernes
        ? CDOW(CTOD("06/12/90"))        // Resultado: Martes

 Ficheros:  La biblioteca asociada es CLIPPER.LIB.


CHR()
 Convierte un código ASCII en un valor de tipo carácter
------------------------------------------------------------------------------
 Sintaxis

     CHR(<nC.digo>) --> cCar

 Argumentos

     <nC.digo> es un código ASCII comprendido entre 0 y 255.

 Devuelve

     CHR() devuelve el carácter correspondiente al código ASCII especificado
     por <nC.digo>.

 Descripción

     CHR() es una función de conversión que convierte un código ASCII en un
     carácter. Es la función inversa de ASC(). CHR() se utiliza en una serie
     de tareas frecuentes, que incluyen:

     .  Env.o de códigos de control y carácteres gr.ficos a la
        pantalla o a la impresora

     .  Emisi.n de se.ales ac.sticas

     .  Conversi.n en carácteres de los valores de retorno de INKEY()

     .  Llenado de la memoria intermedia del teclado

 Notas

     .  Car.cter nulo: El carácter nulo, CHR(0), posee una
        longitud de uno y se trata como cualquier otro carácter. Esto le
        permite envíarlo a cualquier dispositivo o fichero, incluyendo un
        fichero de base de datos.

 Ejemplos

     .  Estos ejemplos muestran la utilización de CHR() con distintos
        argumentos:

        ? CHR(72)                     // Resultado: H
        ? CHR(ASC("A") + 32)          // Resultado: a
        ? CHR(7)                      // Resultado: suena la se.al
                                      // ac.stica

     .  Las siguientes líneas de código muestran la diferencia entre
        una cadena nula y el carácter nulo:

        ? LEN("")                     // Resultado: 0
        ? LEN(CHR(0))                 // Resultado: 1

 Ficheros:  La biblioteca asociada es CLIPPER.LIB.


CMONTH()
 Convierte un valor de fecha en un nombre de mes en formato de cadena de
 carácteres
------------------------------------------------------------------------------
 Sintaxis

     CMONTH(<fFecha>) --> cMes

 Argumentos

     <fFecha> es el valor de fecha que se desea convertir.

 Devuelve

     CMONTH() recibe un valor de fecha y devuelve el nombre del mes, en forma
     de cadena de carácteres. La primera letra está en mayúscula y el resto
     en minúsculas. Si el valor de fecha es nulo, CMONTH() devuelve una
     cadena nula ("").

 Descripción

     CMONTH() es una función de conversión que permite crear cadenas de fecha
     formateadas para informes, etiquetas o pantallas.

 Ejemplos

     .  Los ejemplos siguientes muestran la forma de utilización de
        CMONTH():

        ? CMONTH(DATE())                  // Resultado: Septiembre
        ? CMONTH(DATE() + 45)             // Resultado: Octubre
        ? STR(DAY(DATE())) +;
           SUBSTR(CMONTH(DATE()),1,3)     // Resultado: 1 Sep

 Ficheros: La biblioteca asociada es CLIPPER.LIB.


COL()
 Devuelve la posición de columna del cursor en pantalla
------------------------------------------------------------------------------
 Sintaxis

     COL() --> nCol

 Devuelve

     COL() devuelve un valor numérico entero. El rango permitido para el
     valor de retorno es de cero a MAXCOL().

 Descripción

     COL() es una función de pantalla que devuelve la posición de columna
     actual del cursor. El valor de COL() cambia siempre que var.a la
     posición del cursor en la pantalla. Tanto los mandatos de consola como
     los de pantalla completa pueden cambiar la posición del cursor. COL()
     toma autom.ticamente el valor cero al ejecutar un mandato CLEAR, CLEAR
     SCREEN o CLS.

     COL() se utiliza para colocar el cursor en una columna, respecto a la
     columna actual. Generalmente se utiliza en combinación con ROW() y todas
     las variaciones del mandato @. En particular, utilice COL() y ROW() para
     crear procedimientos o funciónes independientes de la posición en
     pantalla que pasen la posición superior izquierda de fila y columna como
     parámetros.

     Si se ha establecido SET DEVICE TO PRINTER, la salida de los mandatos
     @...SAY se dirige a la impresora y se actualizan PROW() y PCOL() en vez
     de ROW() y COL(). Utilice estas funciónes si desea controlar la posición
     del cabezal de impresión.

 Ejemplos

     .  El ejemplo siguiente muestra en pantalla el nombre de un
        Cliente comenzando en la columna 10. El estado de cuenta del cliente
        aparece, por medio de COL(), a la derecha del último carácter del
        nombre del cliente:

        USE Ventas NEW
        CLS
        @ 1, 10 SAY "Nombre Cliente: " + TRIM(Cliente)
        @ ROW(), COL() + 1 SAY "Estado Cuenta: " + Estado

 Ficheros:  La biblioteca asociada es CLIPPER.LIB.


COLORSELECT()
 Activa un atributo de la lista de atributos de color
------------------------------------------------------------------------------
 Sintaxis

     COLORSELECT(<níndiceColor>) --> NIL

 Devuelve

     Siempre devuelve NIL.

 Argumentos

     <níndiceColor> es un número que corresponde a la posición de orden
     en la lista de atributos de color, establecida con SETCOLOR().

 Descripción

     COLORSELECT() activa el par de colores especificado en la lista actual
     de atributos de color (establecida con SETCOLOR()). Las constantes
     declaradas de <níndiceColor> se definen en COLOR.CH:

     Constantes de COLOR.CH 
     ------------------------------------------------------------------------
     Constante        Valor
     ------------------------------------------------------------------------
     CLR_STANDARD     0
     CLR_ENHANCED     1
     CLR_BORDER       2
     CLR_BACKGROUND   3
     CLR_UNSELECTED   4
     ------------------------------------------------------------------------

     COLORSELECT() no altera el valor actual de SET Color.

     La siguiente tabla describe el ámbito de los valores de color de
     CA-Clipper seleccionables con SETCOLOR():

     configuración de Color
     ------------------------------------------------------------------------
     Valor          ámbito
     ------------------------------------------------------------------------
     Est.ndar       Todosólos mandatos y funciónes mostrados en la pantalla
     Resaltado      Gets y zonas resaltadas de selecci.n
     Borde          Borde de pantalla (no utilizable en monitores EGA y VGA)
     Fondo          No utilizable
     No resaltado   Gets no seleccionados y opciónes de men. no accesibles
     ------------------------------------------------------------------------

 Ejemplos

     .  Este ejemplo muestra la utilización de COLORSELECT() con las
        constantes declaradas de COLOR.CH:

        USE Ventas NEW
        ? SETCOLOR()                       // muestra "W/B,N/B,W/N,W/N,W/N"
                                           // en blanco sobre azul

        COLORSELECT(CLR_ENHANCED )         // se selecciona el par de
                                           // colores de resaltado
        ? "Soy negro y azul"               // mostrado en negro
                                           // sobre azul
        COLORSELECT(CLR_STANDARD)          // restaura el color estándar

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


CTOD()
 Convierte una cadena de fecha en un valor de tipo fecha
------------------------------------------------------------------------------
 Sintaxis

     CTOD(<cFecha>) --> fFecha

 Argumentos

     <cFecha> es una cadena de carácteres que consiste en números que
     representan el mes, d.a y a.o, separados por un carácter no numérico.
     Las cifras del mes, d.a y a.o deben especificarse de acuerdo con el
     formato SET DATE. Si no se especifican cifras para el siglo, .ste se
     determina por las reglas de SET EPOCH.

 Devuelve

     CTOD() devuelve un valor de fecha. Si <cFecha> no es una fecha víaacute;lida,
     CTOD() devuelve una fecha vac.a.

 Descripción

     CTOD() es una función de conversión de carácteres que convierte una
     cadena de carácteres en una fecha. Para inicializar una fecha vac.a para
     la introducci.n de la fecha, especifique <cFecha> como cadena nula (""),
     SPACE(8) o "  /  /  ".

     CTOD() se utiliza siempre que necesite un valor de fecha en forma
     literal. A continúa.ión se dan algunos ejemplos:

     .  Inicializar una variable en un valor de fecha

     .  Especificar una cadena de fecha en forma literal como
        argumento de una cláusula RANGE de @...GET

     .  Especificar una cadena de fecha en forma literal para realizar
        cálculos aritm.ticos con la fecha

     .  Comparar el resultado de una expresión de fecha con una cadena
        de fecha en forma literal

     .  Sustituir un campo de fecha por una cadena de fecha en forma
        literal

     CTOD() es la función inversa de DTOC(), la cual convierte un valor de
     fecha en una cadena de carácteres con el formato especificado por SET
     DATE y SET CENTURY. DTOS() convierte asimismo un valor de fecha en una
     cadena de carácteres con el formato aaaammdd.

 Ejemplos

     .  Este ejemplo utiliza CTOD() para inicializar dos variables de
        fecha, utilizando una como GET y la otra para la víaacute;lidaci.n RANGE:

        SET CENTURY ON
        dInicio := CTOD("01-26-1876")
        dActual := CTOD("")
        @ 10, 10 SAY "Introduzca la fecha:" GET dActual ;
              RANGE dInicio, DATE()
        READ

     .  El ejemplo siguiente utiliza CTOD() para crear un valor de
        fecha dentro de una condición FOR:

        USE Inventario NEW
        REPLACE ALL Inventario->Precio WITH ;
           Inventario->Precio * 1.1 FOR ;
           Inventario->FechaInv < CTOD("10/10/90")

 Ficheros: La biblioteca asociada es CLIPPER.LIB.


CURDIR()
 Devuelve el directorio DOS actual
------------------------------------------------------------------------------
 Sintaxis

     CURDIR([<cEspecUnidad>]) --> cDirectorio

 Argumentos

     <cEspecUnidad> especifica la letra de la unidad de disco que se
     requiere. Si no se especifica, la unidad por defecto es la unidad DOS
     actual.

 Devuelve

     CURDIR() devuelve el directorio DOS actual de la unidad especificada por
     <cEspecUnidad>, como cadena de carácteres sin carácteres de barra
     invertida (\) iniciales o finales.

     Si se produce un error o si el directorio actual de la unidad
     especificada es el directorio ra.z, CURDIR() devuelve una cadena nula
     ("").

 Descripción

     CURDIR() es una función de entorno que le proporciona el nombre del
     directorio DOS actual, ignorando los valores de SET DEFAULT y SET PATH.

 Ejemplos

     .  Los ejemplos siguientes muestran la forma de utilización de
        los distintos resultados de CURDIR():

        ? CURDIR("E:")      // Resultado: cadena nula:directorio ra.z
        ? CURDIR("C")       // Resultado: CLIPPER5\SOURCE
        ? CURDIR("C:")      // Resultado: CLIPPER5\SOURCE
        ? CURDIR()          // Resultado: cadena nula:directorio ra.z
        ? CURDIR("A")       // Resultado: cadena nula:la unidad no est.
                            // preparada

     .  Este ejemplo cambia el directorio DOS actual por un nuevo
        valor, si no coincide con un directorio especificado:

        IF CURDIR("C:") != "CLIPPER5\SOURCE"
           RUN CD \CLIPPER5\SOURCE
        ENDIF

 Ficheros   La biblioteca asociada es EXTEND.LIB,
            el fichero fuente es SOURCE\SAMPLE\EXAMPLEA.ASM



Solo personas registradas pueden poner comentarios