TIME()
 Devuelve la hora del sistema
------------------------------------------------------------------------------
 Sintaxis

     TIME() --> cCadenaHora

 Devuelve

     TIME() devuelve la hora del sistema como una cadena de carácteres en el
     formato hh:mm:ss. hh es la hora en formato de 24 horas, mm son los
     minutos y ss son los segundos

 Descripción

     TIME() es una función horaria que muestra la hora del sistema en la
     pantalla o la imprime en un informe. TIME() está relacionada con
     SECONDS(), que devuelve un valor entero que representa el número de
     segundos desde la media noche. Para cálculos horarios, suele utilizarse
     SECONDS() en vez de TIME()

 Ejemplos

     .  Estos ejemplos muestran el resultado de utilizar TIME() con
        SUBSTR() para extraer los dígitos de hora, minutos y segundos:

        ? TIME()                       // Resultado: 10:37:17
        ? SUBSTR(TIME(), 1, 2)         // Resultado: 10
        ? SUBSTR(TIME(), 4, 2)         // Resultado: 37
        ? SUBSTR(TIME(), 7, 2)         // Resultado: 17

 Ficheros:  La biblioteca asociada es CLIPPER.LIB.


TONE()
 Hace sonar un tono en el altavoz, con la frecuencia y duraci.n especificadas
------------------------------------------------------------------------------
 Sintaxis

     TONE(<nFrecuencia>, <nDuraci.n>) --> NIL

 Argumentos

     <nFrecuencia> es un valor numérico que indica la frecuencia del tono
     que va a sonar.

     <nDuraci.n> es un número positivo que indica la duraci.n del tono
     medida en incrementos de 1/18 de segundo. Por ejemplo, una <nDuraci.n>
     de 18 representa un segundo.

     En ambos argumentos, los valores decimales se truncan, sin redondear,
     para dar la parte entera.

 Devuelve

     TONE() siempre devuelve NIL.

 Descripción

     TONE() es una función de sonido que sirve para indicar al usuario los
     diferentes estados de un programa. Pueden ser estados de error,
     condiciónes l.mite o el final de un proceso muy lento. Por ejemplo, un
     estado de error podr.a generaráun cierto tono antes de alertar al
     usuario con un mensaje o un panel de diálogo interactivo. Una condición
     l.mite podr.a indicar que el usuario est. intentando desplazar el cursor
     m.s all. de la posición superior o inferior de una columna de un objeto
     TBrowse.

     Un proceso por lotes podr.a indicar el momento de terminaci.n con un
     sonido, para alertar al usuario en caso de que .ste se haya alejado de
     la pantalla.

     TONE() trabaja generando tonos con una frecuencia y duraci.n
     especificadas. La duraci.n se mide en incrementos de 1/18 de segundo. La
     frecuencia se mide en hertzios (ciclos por segundo). Las frecuencias por
     debajo de 20 Hz son inaudibles. La tabla siguiente muestra las
     frecuencias de las notas musicales estándar.

     Nota: TONE() sólo opera en ordenadores personales totalmente
     compatibles .

     Tabla de Notas Musicales
     ------------------------------------------------------------------------
     Nota      Frecuencia          Nota       Frecuencia
     ------------------------------------------------------------------------
     C         130,80              C medio    261,70
     C#        138,60              C#         277,20
     D         146,80              D          293,70
     D#        155,60              D#         311,10
     E         164,80              E          329,60
     F         174,60              F          349,20
     F#        185,00              F#         370,00
     G         196,00              G          392,00
     G#        207,70              G#         415,30
     A         220,00              A          440,00
     A#        233,10              A#         466,20
     B         246,90              B          493,90
     C         523,30
     ------------------------------------------------------------------------

 Ejemplos

     .  Este ejemplo es una función que indica con un tono cuando ha
        terminado un proceso por lotes:

     FUNCTION BipTerminacion

           TONE(300, 1)
           TONE(100, 1)
           TONE(300, 1)
           TONE(100, 1)
           RETURN NIL

     .  Este ejemplo es una secuencia de tonos que indican que se han
        pulsado teclas no víaacute;lidas o que se han alcanzado condiciónes l.mite:

        FUNCTION BipError
           TONE(100, 3)
           RETURN NIL

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


TRANSFORM()
 Convierte cualquier valor en una cadena de carácteres formateada
------------------------------------------------------------------------------
 Sintaxis

     TRANSFORM(<exp>, <cPatrónFormatoSay>) --> cCadenaFormato

 Argumentos

     <exp> es el valor que se va a formatear. Puede ser una expresión de
     cualquier tipo de datos víaacute;lido en CA-Clipper excepto matrices, bloques
     de código y NIL.

     <cPatrónFormatoSay> es una cadena de carácteres que describe el
     formato del valor devuelto.

 Devuelve

     TRANSFORM() convierte <exp> en una cadena de carácteres formateada seg.n
     lo definido en<cPatrónFormatoSay>.

 Descripción

     TRANSFORM() es una función de conversión que formatea valores de
     carácteres, fechas, lógicos y numéricos de acuerdo a una cadena de
     formato especificada compuesta por una combinación de funciónes de
     formato y cadenas de plantilla.

     TRANSFORM() formatea los datos para su salida por pantalla o por
     impresora de la misma manera que la cláusula PICTURE del mandato
     @...SAY.

     .  Cadena de función: Cadena que especifica las reglas de
        formato aplicadas al valor devuelto por TRANSFORM() en su conjunto,
        en vez de a las posiciónes de carácter individuales en <exp>. Est.
        formada por el carácter @ seguido de uno o m.s carácteres
        adicionales, cada uno de los cuales tiene un significado determinado
        (consulte la tabla siguiente). Si se indica una cadena de función, el
        carácter @ debe ser el primero a la izquierda de la cadena de
        formato, y la cadena de función no debe contener espacios.

        Puede especificarse una cadena de función sola o acompañada de una
        cadena de plantilla. Si se utilizan ambas, la cadena de función debe
        preceder a la cadena de plantilla y las dos deben estar separadas por
        un espacio.

        funciónes TRANSFORM() 
        ---------------------------------------------------------------------
        función    Acción
        ---------------------------------------------------------------------
        B          Muestra números justificados a la izquierda
        C          Muestra RC después de los números positivos
        D          Muestra las fechas en el formato especificado por SET DATE
        E          Muestra la fecha en formato británico
        R          Inserta carácteres que no aparecen en la plantilla
        X          Muestra DB después de los números negativos
        Z          Muestra los ceros como espacios en blanco
        (          Sitúa los números negativos entre paréntesis
        !          Convierte en mayúsculasólos carácteres alfabéticos
        ---------------------------------------------------------------------

     .  Cadena de plantilla: La cadena de plantilla especifica las
        reglas de formato carácter a carácter. La cadena de plantilla est.
        formada por una serie de carácteres, algunos de los cuales tienen
        significados especiales (consulte la tabla siguiente). Cada posición
        de la cadena de plantilla corresponde a una posición en el valor del
        argumento <exp>. Esta plantilla se utiliza con TRANSFORM(), por lo
        que puede servir para insertar carácteres tales como comas, signos de
        d.lar y paréntesis.

        Los carácteres de la cadena de plantilla que no tengan significados
        asignados se copian literalmente en el valor devuelto. Si se utiliza
        la función de imagen @R, estos carácteres se insertan entre los
        carácteres del valor devuelto; en caso contrario sustituyen a los
        carácteres correspondientes de dicho valor. Puede especificarse una
        cadena de plantilla sola o acompañada de una cadena de función. Si se
        utilizan ambas, la cadena de función debe ir antes que la cadena de
        plantilla y ambas cadenas deben estar separadas por un espacio.

        Plantillas TRANSFORM() 
        ---------------------------------------------------------------------
        Plantilla      Acción
        ---------------------------------------------------------------------
        A,N,X,9,#      Muestra dígitos de cualquier tipo de datos
        L              Muestra los valores lógicos como "T" o "F"
        Y              Muestra los valores lógicos como "S" o "N"
        !              Convierte en mayúscula un carácter alfabético
        $              Muestra un signo de d.lar en cada espacio inicial en
                       blanco de un valor numérico
        *              Muestra un asterisco en cada espacio inicial en blanco
                       de un valor numérico
        .              Especifica una posición de punto decimal
        ,              Especifica una posición de coma
        ---------------------------------------------------------------------

 Ejemplos

     .  Este ejemplo asigna un formato monetario a un número
        utilizando una plantilla:

        ? TRANSFORM(123456, "$999,999")        // Resultado: $123,456

     .  Este ejemplo formatea una cadena de carácteres útilizando una
        función:

        ? TRANSFORM("en mayúsculas", "@!")     // Resultado: EN MAYUSCULAS

 Ficheros:  La biblioteca asociada es CLIPPER.LIB.

TYPE()
 Determina el tipo de una expresión
------------------------------------------------------------------------------
 Sintaxis

     TYPE(<cExp>) --> cTipo

 Argumentos

     <cExp> es la expresión de carácteres cuyo tipo se va a determinar.
     <cExp> puede ser un campo, con o sin alias, una variable pública o
     privada o una expresión de cualquier tipo.

 Devuelve

     TYPE() devuelve uno de los siguientes carácteres:

     Valores Devueltos por TYPE()
     ------------------------------------------------------------------------
     Devuelve     Significado
     ------------------------------------------------------------------------
     A            Matriz
     B            Bloque de C.digo
     C            Car.cter
     D            Fecha
     L            L.gico
     M            Memo
     N            numérico
     O            Objeto
     U            NIL, local o estática
     UE           Error de sintaxis
     UI           Error indeterminado
     ------------------------------------------------------------------------

 Descripción

     TYPE() es una función del sistema que devuelve el tipo de la expresión
     especificada. Puede comprobar la validez de la expresión mientras esta
     utilice funciónes CLIPPER.LIB y no haga referencia a variablesólocales o
     estáticas, funciónes definidas por el usuario o funciónes predefinidas
     contenidas en EXTEND.LIB.

     TYPE() es similar a VALTYPE() , pero utiliza el operador de macro (&)
     para determinar el tipo del argumento. Esto impide utilizar TYPE() para
     determinar el tipo de variablesólocales o estáticas. VALTYPE(), por
     contra, permite evaluar una expresión y determina el tipo de datos del
     valor devuelto. Permite determinar el tipo de funciónes definidas por el
     usuario y de variablesólocales y estáticas.

 Notas

     .  Referencias a matrices: Las referencias a matrices
        públicas y privadas devuelven "A". Las referencias a elementos de
        matrices devuelven el tipo del elemento.

     .  IF(): Para devolver el tipo de datos de una expresión
        IF(), TYPE() eval.a la condición y luego devuelve el tipo de la vía
        especificada. Si la expresión IF() o la vía evaluada no son víaacute;lidos,
        TYPE() devuelve "UE".

     .  Comprobaci.n de parámetros: TYPE() sólo puede comprobar la
        validez de los parámetros recibidos con la sentencia PARAMETERS Al
        verificar un parámetro declarado como parte de una declaración
        FUNCTION o PROCEDURE, devuelve siempre "U.", porque los parámetros
        locales no tienen un s.mbolo en la tabla de s.mbolos. Para determinar
        si se ha saltado un argumento o dejado al final de la lista de
        argumentos, compare el parámetro con NIL o utilice la función
        VALTYPE().

     .  funciónes definidas por el usuario y contenidas en
        EXTEND.LIB Si en una expresión se hace una referencia a una función
        que no se encuentra en CLIPPER.LIB (una función definida por el
        usuario o EXTEND.LIB ), TYPE() devuelve "UI." Si la función definida
        por el usuario no ha sido enlazada al programa actual, TYPE()
        devuelve "U.".

 Ejemplos

     .  Estos ejemplos muestran diversos resultados de la utilización
        de TYPE():

        ? TYPE('SUBSTR("Hola, .qu. tal?", 4, 5)')    // Resultado: C
        ? TYPE("UDF()")                              // Resultado: UI
        ? TYPE('IF(.T., "verdadero", 12)')           // Resultado: C

     .  Este ejemplo muestra dos m.todos de comprobar la existencia y
        tipo de los parámetros declarados:

        FUNCTION ParamPrueba
           PARAMETERS cParam1, nParam2
           IF cParam1 = NIL
              ? "No se ha pasado el primer parámetro"
              cParam1 := "Valor por defecto"
           ENDIF
           //
           IF TYPE(nParam2) == "U"
              ? "No se ha pasado el segundo parámetro"
           ENDIF
           .
           . <sentencias>
           .
           RETURN NIL

 Ficheros: La biblioteca asociada es CLIPPER.LIB.


UPDATED()
 Determina si ha cambiado un objeto GET durante un mandato READ
------------------------------------------------------------------------------
 Sintaxis

     UPDATED() --> lCambio

 Devuelve

     UPDATED() devuelve verdadero (.T.) si se han a.adido o modificado datos
     en un GET; en caso contrario devuelve falso (.F.).

 Descripción

     UPDATED() determina si se han introducido satisfactoriamente los
     carácteres en el objeto GET desde el teclado utilizando el READ m.s
     reciente. Cada vez que se ejecuta un READ, UPDATED() toma el valor falso
     (.F.). Cada vez que se accede a un objeto GET desde el teclado,
     UPDATED() toma el valor verdadero (.T.) después de que el usuario sale
     del objeto GET. Si el usuario pulsa Esc antes de salir del primer objeto
     GET editado, UPDATED() sigue siendo falso (.F.). Cuando UPDATED() toma
     el valor verdadero (.T.), mantiene este valor, hasta que se ejecuta el
     siguiente READ.

     En un procedimiento SET KEY o VALID puede cambiar la variable del GET
     actual utilizando el mandato KEYBOARD o asign.ndole un nuevo valor con
     cualquiera de los operadores de asignación. Cambiar el valor de la
     variable con KEYBOARD tiene el mismo efecto que si el usuario hubiera
     introducido el cambio directamente desde el teclado, y UPDATED()
     devuelve el valor correspondiente. No obstante, como UPDATED() refleja
     sólo los cambios realizados desde el teclado, una asignación de la
     variable del GET no afecta a UPDATED().

 Ejemplos

     .  Este ejemplo asigna valores de campos de Clientes.dbf a
        variables y las edita. Si el usuario cambia cualquiera de estos
        valores, las variables de campo para el registro actual se actualizan
        con los nuevos valores:

        USE Cliente NEW
        CLEAR
        MEMVAR->Cliente = Cliente->Cliente
        MEMVAR->Direccion = Cliente->Direccion
        @ 1, 1 SAY "Nombre:" GET MEMVAR->Cliente
        @ 2, 1 SAY "Direccion:" GET MEMVAR->Direccion
        READ
        //
        IF UPDATED()
           Cliente->Cliente := MEMVAR->Cliente
           Cliente->Direccion := MEMVAR->Direccion
        ENDIF

 Ficheros:  La biblioteca asociada es CLIPPER.LIB.


UPPER()
 Convierte todas las minúsculas en mayúsculas
------------------------------------------------------------------------------
 Sintaxis

     UPPER(<cCadena>) --> cCadenaMay.s

 Argumentos

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

 Devuelve

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

 Descripción

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

     UPPER() se utiliza normalmente para formatear cadenas de carácteres con
     fines de visualización. También puede utilizarse para homogeneizar
     cadenas en comparaciones que no diferencian mayúsculas y minúsculas o
     para ordenación con INDEX.

 Ejemplos

     .  Este ejemplo muestra el resultado de UPPER():

        ? UPPER("una cadena")            // Resultado: UNA CADENA
        ? UPPER("123 carac = <>")        // Resultado: 123 CARAC = <>

     .  Este ejemplo utiliza UPPER() como parte de una condición
        independiente de mayúsculas y minúsculas:

        USE Cliente INDEX NombreCliente NEW
        LIST NombreCliente FOR "KATE" $ UPPER(Cliente)

     .  UPPER() es útil también para crear expresiónes clave de
        ííndices, independientes de mayúsculas y minúsculas:

        USE Cliente NEW
        INDEX ON UPPER(último) TO últimoCliente

     .  A continúa.ión, puede utilizar esta expresión para buscar
        Clientes:

        MEMVAR->último = SPACE(15)
        @ 10, 10 GET MEMVAR->último
        READ
        SEEK UPPER(MEMVAR->último)

 Ficheros:  La biblioteca asociada es CLIPPER.LIB.

USED()
 Determina si se est. utilizando un fichero de base de datos
------------------------------------------------------------------------------
 Sintaxis

     USED() --> lFichAbierto

 Devuelve

     USED() devuelve verdadero (.T.) si existe alg.n fichero de base de datos
     abierto; en caso contrario devuelve falso (.F.)


 Descripción

     USED() es una función de base de datos que determina si existe alg.n
     fichero de base de datos abierto o en un área de trabajo determinada.
     Por defecto, USED() act.a en el área de trabajo seleccionada
     actualmente. Si desea que act.e en un área de trabajo no seleccionada,
     debe especificarse como parte de una expresión de alias.

 Ejemplos

     .  Este ejemplo determina si se est. utilizando un fichero de
        base de datos en el área de trabajo actual:

        USE Cliente NEW
        ? USED()               // Resultado: .T.
        CLOSE
        ? USED()               // Resultado: .F.

 Ficheros:  La biblioteca asociada es CLIPPER.LIB.


VAL()
 Convierte un valor de carácteres en un valor numérico
------------------------------------------------------------------------------
 Sintaxis

     VAL(<cnúmero>) --> nNúmero

 Argumentos

     <cnúmero> es la expresión de carácteres que se va a convertir.

 Devuelve

     VAL() devuelve <cnúmero> convertido en un valor numérico, incluyendo
     dígitos decimales.

 Descripción

     VAL() es una función de conversión que convierte una cadena de
     carácteres que contiene dígitos numéricos en un valor numérico. Al
     ejecutar VAL(), eval.a <cnúmero> hasta una segunda coma decimal, el
     primer carácter no numérico o el final de la expresión. Los espacios en
     blanco iniciales se ignoran. Si se ha establecido SET FIXED ON, VAL()
     devuelve el número de lugares decimales especificado por SET DECIMALS,
     redondeando <cnúmero> si se especifica con m.s dígitos que el valor
     DECIMALS actual. Igual que las otras funciónes de redondeo, los dígitos
     comprendidos entre cero y cuatro se redondean hacia abajo y los dígitos
     entre cinco y nueve se redondean hacia arriba. Si se ha establecido SET
     FIXED OFF, VAL() devuelve el número de lugares decimales especificado
     entre <cnúmero>.

     VAL() es la opuesta de STR() y TRANSFORM() que convierten valores
     numéricos en cadenas de carácteres.

 Ejemplos

     .  Estos ejemplos muestran la utilización de VAL() con SET FIXED
        ON y SET DECIMALS TO 2:

        SET DECIMALS TO 2
        SET FIXED ON
        //
        ? VAL("12,1234")           // Resultado:   12,12
        ? VAL("12,1256")           // Resultado:   12,13
        ? VAL("12A12")             // Resultado:   12
        ? VAL("A1212")             // Resultado:    0
        ? VAL(SPACE(0))            // Resultado:    0
        ? VAL(SPACE(1))            // Resultado:    0
        ? VAL(" 12,12")            // Resultado:   12,12
        ? VAL("12 ,12")            // Resultado:   12,00

 Ficheros:  La biblioteca asociada es CLIPPER.LIB.

VALTYPE()
 Determina el tipo de datos devuelto por una expresión
------------------------------------------------------------------------------
 Sintaxis

     VALTYPE(<exp>) --> cTipo

 Argumentos

     <exp> es una expresión de cualquier tipo.

 Devuelve

     VALTYPE() devuelve un carácter sencillo que representa el tipo de datos
     devuelto por <Exp>. VALTYPE() devuelve uno de los siguientes carácteres:

     Valores Devueltos por VALTYPE()
     ------------------------------------------------------------------------
     Devuelve     Significado
     ------------------------------------------------------------------------
     A            Matriz
     B            Bloque de código
     C            Car.cter
     D            Fecha
     L            L.gico
     M            Memo
     N            numérico
     O            Objeto
     U            NIL
     ------------------------------------------------------------------------

 Descripción

     VALTYPE() es una función del sistema que toma un argumento, lo eval.a y
     devuelve una cadena de carácteres que describe el tipo de datos del
     valor devuelto. Es similar a TYPE() pero difiere en que eval.a realmente
     el argumento especificado y determina el tipo del valor devuelto. Por
     esta raz.n, permite determinar el tipo de las variablesólocales y
     estáticas, funciónes definidas por el usuario y funciónes de la
     biblioteca EXTEND.LIB. TYPE(), por el contrario, utiliza el operador de
     macro (&) para evaluar el tipo del argumento. Observe que si el
     argumento no existe se producirá un error ("error no definido"), a
     diferencia de TYPE que devuelve "U".

 Ejemplos

     .  Estos ejemplos muestran los valores de retorno para varios
        tipos de datos:

        ? VALTYPE(1)                 // Resultado: N
        ? VALTYPE("GOOB")            // Resultado: C
        ? VALTYPE(NIL)               // Resultado: U
        ? VALTYPE(matriz)            // Resultado: A

        ? VALTYPE(bloque)            // Resultado: B

 Ficheros:  La biblioteca asociada es CLIPPER.LIB.


VERSION()
 Devuelve la versi.n de CA-Clipper
------------------------------------------------------------------------------
 Sintaxis

     VERSION() --> cVersi.n

 Devuelve

     VERSION() devuelve el número de versi.n de la biblioteca EXTEND.LIB,
     como un valor de carácteres.

 Descripción

     VERSION() es una función de entorno que devuelve el número de versi.n de
     la biblioteca EXTEND.LIB de CA-Clipper.

 Ficheros:  La biblioteca asociada es EXTEND.LIB.

WORD()*
 Convierte los parámetros numéricos del mandato CALL de doble precisión a
 enteros sencillos
------------------------------------------------------------------------------
 Sintaxis


     WORD(<nNúmero>) --> NIL

 Argumentos

     <nNúmero> es el valor numérico que se va a convertir en entero,
     especificado en el rango de m.s/menos 32.767, inclusive.

 Devuelve

     Utilizado como un argumento del mandato CALL WORD() devuelve un número
     entero. En cualquier otro contexto, devuelve NIL.

 Descripción

     WORD() es una función de conversión que convierte los parámetros
     numéricos del mandato CALL de doble precisión a enteros. WORD() es una
     función de compatibilidad, por lo que su utilización no es recomendable.
     Tanto el mandato CALL como la función WORD() se anulan por los programas
     del Sistema Extendido. Si desea más información, consulte el capítulo
     Utilizaci.n del Sistema Extendido en el Manual de Consulta T.cnica.

 Ejemplos

     .  Este ejemplo utiliza WORD() como argumento del mandato CALL:

        CALL Cproc WITH WORD(30000), "Un texto"

 Ficheros:  La biblioteca asociada es CLIPPER.LIB.

YEAR()
 Convierte un valor de fecha en un a.o en formato numérico
------------------------------------------------------------------------------
 Sintaxis

     YEAR(<fFecha>) --> nA.o

 Argumentos

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

 Devuelve

     YEAR() devuelve el a.o contenido en el valor de fecha especificado,
     insertando las cifras de siglo para dar un valor numérico de cuarto
     dígitos. El valor que devuelve no depende del formato actual de
     SET DATE o SET CENTURY. Si se especifica una fecha nula, (CTOD(""))
     devuelve cero.

 Descripción

     YEAR() es una función de conversión que convierte un valor de fecha en
     un a.o en formato numérico. Se utiliza para cálculos en informes
     peri.dicos o para mostrar fechas con formato.

     YEAR() forma parte de un grupo de funciónes que devuelven los
     componentes de un valor de fecha en formato numérico. Este grupo incluye
     DAY() y MONTH() que devuelven el d.a y el mes, respectivamente, como
     valores numéricos.

 Ejemplos

     .  Estos ejemplos muestran la utilización de YEAR() utilizando la
        fecha del sistema:

        ? DATE()                     // Resultado: 09/20/90
        ? YEAR(DATE())               // Resultado: 1990
        ? YEAR(DATE()) + 11          // Resultado: 2001

     .  Este ejemplo crea una función definida por el usuario que
        utiliza YEAR() para dar formato a un valor de fecha como mes, d.a,
        a.o:

        ? Mdy(DATE())                // Resultado: 20 de Septiembre de 1990

        FUNCTION Mdy( fFecha )
           RETURN (LTRIM(STR(DAY(fFecha))) + "de" + cMonth(fFecha) +" "+;
                    STR(YEAR(fFecha))

 Ficheros: La biblioteca asociada es CLIPPER.LIB.

Solo personas registradas pueden poner comentarios