AADD() Añade un nuevo elemento al final de una matriz ------------------------------------------------------------------------------ Sintaxis AADD(<aDestáno >, <expValor>) --> Valor Argumentos <aDestáno> es la matriz a la que se va a a.adir un nuevo elemento. <expValor> es el valor que se va a asignar al nuevo elemento. Devuelve AADD() eval.a <expValor> y devuelve su valor. Si no se especifica <expValor>, AADD() devuelve NIL. Descripción AADD() es una función de tratamiento de matrices que aumenta en uno la longitud real de la matriz destáno. Al elemento reci.n creado se le asigna el valor especificado por <expValor>. AADD() se utiliza para ampliar din.micamente una matriz. Resulta .til para crear listas o colas din.micas. Un buen ejemplo de esto es la matriz GetList, que utiliza el sistema GET para almacenar objetos Get. Despu.s de ejecutar READ o CLEAR GETS, GetList pasa a ser una matriz vac.a. Cada vez que se ejecuta un mandato @...GET, el sistema GET utiliza AADD() para a.adir un elemento nuevo al final de la matriz GetList y, a continúa.ión, asigna un nuevo objeto Get al nuevo elemento. AADD() es similar a ASIZE(), excepto en que a.ade los elementos de uno en uno. ASIZE(), en cambio, puede ampliar o reducir una matriz directamente a un tama.o especificado. AADD() tiene la ventaja de que permite asignar un valor al nuevo elemento, mientras que ASIZE() no lo permite. AADD() también puede parecer similar a AINS(), pero se diferencian en que AINS() desplaza elementos dentro de una matriz, pero no cambia la longitud de la misma. Nota: Si <expValor> es otra matriz, el nuevo elemento de la matriz destáno contendr. una referencia a la matriz especificada por <expValor>. Ejemplos . Los ejemplos siguientes muestran los resultados de llamadas m.ltiples a AADD() con una matriz: aMatriz := {} //Resultado: aMatriz es una matriz //vac.a AADD(aMatriz, 5) //Resultado: aMatriz es { 5 } AADD(aMatriz, 10) //Resultado: aMatriz es { 5, 10 } AADD(aMatriz, { 12, 10 }) //Resultado: aMatriz es //{ 5, 10, { 12, 10 } } Ficheros: La biblioteca asociada es CLIPPER.LIB.

ABS()
 Devuelve el valor absoluto de una expresión numérica
------------------------------------------------------------------------------
 Sintaxis

     ABS(<nExp>) --> nPositivo

 Argumentos

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

 Devuelve

     ABS() devuelve un número que representa el valor absoluto de su
     argumento. El valor devuelto puede ser un número positivo o cero.

 Descripción

     ABS() es una función numérica que determina la magnitud de un valor
     numérico, independientemente de su signo. Permite, por ejemplo, obtener
     la diferencia entre dos números como valor positivo, sin conocer de
     antemano cu.l de los dos es mayor.

     Formalmente, ABS(x) se define en función de su argumento x de la
     siguiente manera: si x >= 0, ABS(x) devuelve x; en caso contrario,
     ABS(x) devuelve el valor negativo de x.

 Ejemplos

     .  Los ejemplos siguientes muestran resultados t.picos de ABS():

        nNum1 := 100
        nNum2 := 150
        ? nNum1 - nNum2              //Resultado:-50
        ? ABS(nNum1 - nNum2)         //Resultado: 50
        ? ABS(nNum2 - nNum1)         //Resultado: 50
        ? ABS(-12)                   //Resultado: 12
        ? ABS(0)                     //Resultado: 0

 Ficheros:  La biblioteca asociada es CLIPPER.LIB.


ACHOICE()
 Ejecuta un men. emergente
------------------------------------------------------------------------------
 Sintaxis

     ACHOICE(<nSup>, <nIzq>, <nInf>, <nDer>,
        <acElementosMen.>,
        [<alElementosSeleccionables> |
        <lElementosSeleccionables>],
        [<cfunciónUsuario>],
        [<nElementoInicial>],
        [<nFilaVentana>]) --> nPosici.n

 Argumentos

     <nSup>, <nIzq> y <nInf>, <nDer> son las coordenadas
     superior izquierda e inferior derecha de la ventana. Los valores de fila
     pueden estar comprendidos entre cero y MAXROW() y los valores de columna
     entre cero y MAXCOL().

     <acElementosMen.> es una matriz de cadenas de carácteres que se va a
     mostrar como elementos de men.. Los elementos de men. individuales se
     identifican por sus posiciónes numéricas en esta matriz.

     <alElementosSeleccionables> es una matriz paralela de valores
     lógicos (un elemento para cada elemento de <acElementosMen.>), que
     especifica los elementos de men. seleccionables. Los elementos de esta
     matriz pueden ser valores lógicos o cadenas de carácteres. ACHOICE() no
     permite cadenas nulas y detiene la visualización si encuentra una. Si
     alg.n elemento es una cadena de carácteres, se eval.a como
     macroexpresión y debe dar  un resultado de tipo l.gico. En cualquier
     caso, un valor falso (.F.) significa que el elemento de men.
     correspondiente no va a estar disponible y un valor verdadero (.T.)
     significa que lo estar.. Si se especifica los <lElementosSeleccionables>
     en vez de una matriz, falso (.F.) hace que los elementos de men. no
     están disponibles y verdadero (.T.) hace que lo están. Por defecto,
     todos los elementos de men. están disponibles para su selecci.n.

     <cfunciónUsuario> es el nombre de una función que se ejecuta cuando
     se pulsa una tecla irreconocible. El nombre de función debe
     especificarse como una expresión de carácteres sin paréntesis ni
     argumentos. Recuerde que el comportamiento de ACHOICE() se ve afectado
     por la presencia de este argumento. Si desea más información, consulte
     el comentario siguiente.

     <nElementoInicial> es la posición en la matriz <acElementosMen.> del
     elemento que aparece resaltado al mostrarse el men. por primera vez. Si
     se especifica un elemento de men. no disponible o no se especifican
     argumentos, el elemento de men. inicial ser. el primer elemento
     seleccionable de la matriz.

     <nFilaVentana> es el número de fila de la ventana en la que aparece
     el elemento de men. inicial. La numeraci.n de las filas comienza desde
     cero. Por defecto, el elemento de men. inicial aparece lo m.s cerca
     posible de la parte superior de la ventana, sin dejar filas vac.as al
     final. Si existen suficientes elementos de men. a continúa.ión del
     elemento inicial para llenar la ventana, el elemento inicial aparece en
     la primera fila (fila cero) del men.. Este argumento se utiliza para
     controlar el aspecto del men. inicial cuando hay m.s elementos de men.
     de los que caben en la ventana.

     Como ocurre con las dem.s funciónes, los argumentos opciónales pueden
     omitirse utilizando una coma en vez del argumento real.

 Devuelve

     ACHOICE() devuelve la posición numérica en la matriz <acElementosMen.>
     del elemento de men. seleccionado. Si se aborta el proceso de selecci.n,
     ACHOICE() devuelve cero.

 Descripción

     ACHOICE() es una función de interfaz de usuario que permite crear varios
     tipos de men.s emergentes. Cada men. utiliza una matriz de cadenas de
     carácteres como elementos de men. y una matriz paralela de valores
     lógicos para determinar si los elementos deben ser seleccionables o no.
     Cuando se invoca ACHOICE(), la lista de elementos de men. aparece dentro
     de las coordenadas de ventana especificadas. Si el usuario pulsa Intro,
     se selecciona el elemento actual y ACHOICE() devuelve la posición del
     elemento de men. en <acElementosMen.>. Si el usuario pulsa Esc,
     ACHOICE() se aborta y devuelve cero.

     Los elementos de men. pueden desplazarse si el número de elementos
     de <acElementosMen.> excede el número de filas de la ventana de men.
     y el usuario intenta desplazar la zona resaltada m.s all. del
     principio o del final de la ventana. Recuerde que la zona resaltada
     no salta de línea cuando se llega al principio o al final de la
     lista de elementos. No obstante, la zona resaltada puede saltar de
     línea si se pulsa la primera letra de un elemento del grupo cuya
     primera letra coincida con la tecla pulsada.

     .  Desplazamiento por el men.: ACHOICE() posee dos modos,
        dependiendo de si se especifica el argumento <cfunciónUsuario>. Si no
        se especifica, se activan las siguientes teclas de desplazamiento:

        Teclas de ACHOICE() (sin función de usuario)
        ---------------------------------------------------------------------
        Tecla          Acción
        ---------------------------------------------------------------------
        Arriba         Va al elemento anterior
        Abajo          Va al elemento siguiente
        Inicio         Va al primer elemento del men.
        Fin            Va al último elemento del men.
        Ctrl-Inicio    Va al primer elemento de la ventana
        Ctrl-Fin       Va al último elemento de la ventana
        ReP.g          Va a la p.gina anterior
        AvP.g          Va a la p.gina siguiente
        Ctrl-ReP.g     Va al primer elemento del men.
        Ctrl-AvP.g     Va al último elemento del men.
        Intro          Selecciona el elemento actual
        Esc            Anula la selecci.n
        Izquierda      Anula la selecci.n
        Derecha        Anula la selecci.n
        Primera Letra  Va al elemento siguiente que comience con esa letra
        ---------------------------------------------------------------------

     .  Color: Los elementos de men. aparecen en el color
        estándar, la zona resaltada en el color resaltado y los elementos no
        disponibles en el color no seleccionado. Por ejemplo, la siguiente
        sentencia de color:

        SETCOLOR("W+/N, BG+/B, , , W/N")

        muestra un men. blanco brillante sobre negro, la zona resaltada en
        c.an brillante sobre azul y los elementos de men. no disponibles en
        blanco atenuado sobre negro.

     .  función de Usuario: Al igual que las restántes funciónes
        de interfaz de usuario, ACHOICE() permite utilizar una función
        definida por el usuario. Esta función se especifica cuando se desean
        anidar invocaciones a ACHOICE() para crear men.s jer.rquicos o
        redefinir teclas.

        Si se especifica una función de usuario, ACHOICE() sólo procesa
        autom.ticamente un grupo de teclas reducido que se lista en la tabla
        siguiente. Todas las dem.s teclas generan una excepci.n de teclado
        que pasa el control a la función de usuario para su tratamiento. El
        control pasa también a la función de usuario cuando ACHOICE() queda
        inactiva (es decir, cuando no quedan teclas para procesar).

        Teclas de ACHOICE() (función de Usuario Especificada)
        ---------------------------------------------------------------------
        Tecla          Acción
        ---------------------------------------------------------------------
        Arriba         Va al elemento anterior
        Abajo          Va al elemento siguiente
        Ctrl-Inicio    Va al primer elemento de la ventana
        Ctrl-Fin       Va al último elemento de la ventana
        ReP.g          Va a la p.gina anterior
        AvP.g          Va a la p.gina siguiente
        Ctrl-ReP.g     Va al primer elemento del men.
        Ctrl-AvP.g     Va al último elemento del men.
        ---------------------------------------------------------------------

        Cuando ACHOICE() ejecuta la función de usuario, le pasa
        autom.ticamente estos tres parámetros:

        -  Modo actual de ACHOICE()

        -  Elemento actual de la matriz de elementos

        -  Posici.n de fila relativa en la ventana de men.

        El modo indica el estado actual de ACHOICE(), que depende de la tecla
        pulsada y de la acci.n que realiza ACHOICE() antes de ejecutar la
        función de usuario. El parámetro de modo puede poseer los valores que
        se indican a continúa.ión:

        Modos de ACHOICE() 
        ---------------------------------------------------------------------
        Modo    Achoice.ch       Descripción
        ---------------------------------------------------------------------
        0       AC_IDLE          Inactivo
        1       AC_HITTOP        Intento de desplazar el cursor por encima del
                                 principio de la lista
        2       AC_HITBOTTOM     Intento de desplazar el cursor por debajo del
                                 final de la lista
        3       AC_EXCEPT        Excepciones del teclado
        4       AC_NOITEM        No quedan elementos seleccionables
        ---------------------------------------------------------------------

        Una vez que la función de usuario completa las acciones
        correspondientes al modo de ACHOICE() o de LASTKEY(), devuelve un
        valor que solicita ACHOICE() que realice una de las operación.s
        siguientes:

        Valores de Retorno de la función de Usuario de ACHOICE() 
        ---------------------------------------------------------------------
        Valor     Achoice.ch      Acción
        ---------------------------------------------------------------------
        0         AC_ABORT        Anular la selecci.n
        1         AC_SELECT       Confirmar la selecci.n
        2         AC_CONT         Continuar ACHOICE()
        3         AC_GOTO         Ir al pr.ximo elemento cuyo primer carácter
                                  coincida con la tecla pulsada
        ---------------------------------------------------------------------

 Ejemplos

     .  El ejemplo siguiente utiliza dos matrices literales que
        especifican los elementos de men. y los criterios de selecci.n.
        Cuando el men. aparece en pantalla y el usuario ha realizado la
        selecci.n, se muestra el nombre del elemento de men. seleccionado:

        acElementosMenu := {"Uno", "Dos", "-------", "Tres"}
        alElementosSeleccionables := {.T., .T., .F., .T.}
        nPosicion := ACHOICE(10, 10, 12, 15, acElementosMenu,;
                                 alElementosSeleccionables)
        ? acElementosMenu [nPosicion]

     .  El ejemplo siguiente declara una matriz de elementos de men. y
        utiliza una función de usuario que muestra un mensaje con cada opción
        resaltada:

        #include "achoice.ch"
        #include "inkey.ch"

        PROCEDURE Main()

           LOCAL acElementosMenu [4], nValDev

        LOCAL nTecla, nPos

           acElementosMenu[1] := "A.adir"
           acElementosMenu[2] := "Editar"
           acElementosMenu[3] := "Borrar"
           acElementosMenu[4] := "Actualizar"

           CLS

           nPos := ACHOICE( 10, 10, 13, 15, acElementosMenu,;
                          .T., "cfunciónUsuario" )
           DO CASE
           CASE nPos == 1
           // Poner aqu. la rutina que a.ade
           CASE nPos == 2
           // Poner aqu. la rutina que edita
           CASE nPos == 3
           // Poner aqu. la rutina que borra
           CASE nPos ==4
           // Poner aqu. la rutina que actualiza
           ENDCASE

        RETURN


        FUNCTION cfunciónUsuario (nModo nElementoAct nRosFila)

           LOCAL nValDev := AC_CONT         //Por defecto,
                                            //continúa.
           LOCAL nTecla := LASTKEY()
           DO CASE
        // Despu.s de procesar todas las teclas
        //pendientes, se visualiza el mensaje
           CASE nModo == AC_IDLE
           DO CASE
              CASE nElementoAct == 1
                 @ 22, 5 SAY " A.adiendo   "
              CASE nElementoAct == 2
                 @ 22, 5 SAY " Editando   "
              CASE nElementoAct == 3
                 @ 22, 5 SAY " Borrando   "
              CASE nElementoAct == 4
                 @ 22, 5 SAY " Actualizando   "
           ENDCASE

              nValDev := AC_CONT            // Continuar ACHOICE()

           CASE nModo == AC_HITTOP          // Intento de ir antes
                                            // del principio
              TONE( 100, 3 )
           CASE nModo == AC_HITBOTTOM       // Intento de ir
                                            // por debajo del final
              TONE( 100, 3 )

           CASE nModo == AC_EXCEPT          // Excepci.n de teclado
              DO CASE
              CASE nTecla == K_RETURN       // Si se pulsa la
                                            // tecla INTRO,
                                            // confirmar selecci.n
                 nValDev := AC_SELECT
              CASE nTecla == K_ESC          // Si se pulsa la tecla
                                            // ESCAPE, anular selecci.n
                 nValDev := AC_ABORT
              OTHERWISE
                    nValDev := AC_GOTO      // En caso
                                            // contrario, ir al
                                            // elemento

              ENDCASE
           ENDCASE

        RETURN nValDev

     .  El ejemplo siguiente declara las matrices, especifica una
        condición de selecci.n para uno de los elementos de men. y utiliza
        una función de usuario:

        EXTERNAL UPDATED
        //
        FUNCTION MiMenu

           LOCAL acElementosMenu[4], alElementosSeleccionables[4],;
                  cfunciónUsuario := "Hacerlo"
           //
           acElementosMenu[1] := "A.adir Registro"
           acElementosMenu[2] := "Editar Registro"
           acElementosMenu[3] := "Borrar Registro"
           acElementosMenu[4] := "Actualizar Registro"
           //
           alElementosSeleccionables[1] := .T.
           alElementosSeleccionables[2] := .T.
           alElementosSeleccionables[3] := .T.
           alElementosSeleccionables[4] := "!UPDATED()"
           // Condici.n de Selecci.n
           RETURN ACHOICE(10, 10, 12, 15, acElementosMenu,;
              alElementosSeleccionables, cfunciónUsuario)

     .  El ejemplo siguiente utiliza dos matrices que especifican los
        elementos de men. y los bloques de acci.n correspondientes. Cuando el
        men. aparece en pantalla y el usuario ha realizado una selecci.n, se
        utiliza el valor de retorno de ACHOICE() para determinar qu. bloque
        de acciones de aElementosAcción debe evaluarse:

        PROCEDURE Main()
           LOCAL nSeleccion
           LOCAL aElementosMenu := { "A.adir Registro ", ;
                                    "Editar Registro ", ;
                                    "Borrar Registro", ;
                                    "Actualizar Registro"  }

           LOCAL aElementosAcción := { {|| AnadFunc() }, ;
                                    {|| EditFunc() }, ;
                                    {|| BorrFunc() }, ;
                                    {|| ActuFunc() } }

           nSeleccion := ACHOICE( 10, 10, 13, 22, aElementosMenu )

           IF nSeleccion == 0
              QUIT      // Se ha pulsado ESCAPE
           ENDIF

           EVAL( aElementosAcción [nSeleccion] )

        RETURN

 Ficheros:  La biblioteca asociada es EXTEND.LIB, los ficheros de cabecera
            asociados son Achoice.ch e Inkey.ch.


ACLONE()
 Duplica una matriz anidada o multidimensiónal
------------------------------------------------------------------------------
 Sintaxis

     ACLONE(<aFuente>) --> aDuplicado

 Argumentos

     <aFuente> es la matriz que se va a duplicar.

 Devuelve

     ACLONE() devuelve un duplicado de <aFuente>.

 Descripción

     ACLONE() es una función de matrices que crea un duplicado completo de la
     matriz <aFuente>. Si <aFuente> contiene submatrices, ACLONE() crea las
     submatrices correspondientes y las llena con copias de los valores de
     las submatrices de <aFuente>. ACLONE() es similar a ACOPY(), pero
     ACOPY() no duplica matrices anidadas.

 Ejemplos

     .  El ejemplo siguiente crea una matriz y luego la duplica con
        ACLONE(). Luego, la primera matriz se modifica, pero la copia
        duplicada no resulta afectada:

        LOCAL aUno, aDos
        aUno := { 1, 2, 3 }         //Resultado: aUno es {1, 2, 3}
        aDos := ACLONE(aUno)        //Resultado: aDos es {1, 2, 3}
        aUno[1] := 99               //Resultado: aUno es {99, 2, 3}
                                    //aDos sigue siendo {1, 2, 3}

 Ficheros:  La biblioteca asociada es CLIPPER.LIB.


ACOPY()
 Copia elementos de una matriz a otra
------------------------------------------------------------------------------
 Sintaxis

     ACOPY(<aFuente>, <aDestáno>, [<nInicio>],
        [<nPosiciones>], [<nPosDestáno>]) --> aDestáno

 Argumentos

     <aFuente> es la matriz cuyos elementos se van a copiar.

     <aDestáno> es la matriz en la que se van a copiar los elementos.

     <nInicio> es la posición del elemento inicial de la matriz
     <aFuente>. Si no se especifica, el valor por defecto es uno.

     <nPosiciones> es el número de elementos que se van a copiar de
     <aFuente>, comenzando en la posición <nInicio>. Si no se especifica
     <nPosiciones>, se copian todos los elementos de <aFuente> desde el
     elemento inicial.

     <nPosDestáno> es la posición del elemento inicial de la matriz
     <aDestáno> que va a recibir los elementos de <aFuente>. Si no se
     especifica, el valor por defecto es uno.

 Devuelve

     ACOPY() devuelve una referencia a la matriz destáno, <aDestáno>.

 Descripción

     ACOPY() es una función de matrices que copia elementos de la matriz
     <aFuente> en la matriz <aDestáno>. La matriz <aDestáno> debe existir
     prevíamente y debe ser lo suficientemente grande para almacenar los
     elementos copiados. Si la matriz <aFuente> tiene m.s elementos, algunos
     de ellos no se copiar.n.

     ACOPY() copia valores de cualquier tipo de datos, incluyendo NIL y
     bloques de código. Si un elemento de la matriz <aFuente> es una
     submatriz, el elemento correspondiente de la matriz <aDestáno> contendr.
     una referencia a la submatriz. Por tanto, ACOPY() no crear. un duplicado
     completo de una matriz multidimensiónal. Para ello, es necesario
     utilizar la función ACLONE().

 Ejemplos

     .  El ejemplo siguiente crea dos matrices, cada una de las cuales
        se llena con un valor. A continúa.ión, los dos primeros elementos de
        la matriz fuente se copian en la matriz destáno:

        LOCAL nPosiciones := 2, nInicio := 1, aUno, aDos
        aUno := { 1, 1, 1 }
        aDos := { 2, 2, 2 }
        ACOPY(aUno, aDos, nInicio, nPosiciones)
        //Resultado: aDos ahora es { 1, 1, 2 }

 Ficheros:  La biblioteca asociada es CLIPPER.LIB.

ADEL()
 Borra un elemento de una matriz
------------------------------------------------------------------------------
 Sintaxis

     ADEL(<aDestáno>, <nPosici.n>) --> aDestáno

 Argumentos

     <aDestáno> es la matriz cuyo elemento se va a borrar.

     <nPosici.n> es la posición del elemento que se va a borrar.

 Devuelve

     ADEL() devuelve una referencia a la matriz destáno, <aDestáno>.

 Descripción

     ADEL() es una función de matrices que borra un elemento de una matriz.
     El contenido del elemento de matriz especificado se pierde y todos los
     elementos que haya desde esa posición hasta el final de la matriz se
     desplazan una posición. El último elemento de la matriz toma el valor
     NIL.

     .Advertencia! CA-Clipper crea las matrices multidimensiónales
     anidando unas matrices dentro de otras. Si la matriz <aDestáno> es una
     matriz multidimensiónal, ADEL() puede borrar una submatriz completa si
     se encuentra en <nPosici.n>, haciendo que <aDestáno> describa una matriz
     con una estructura diferente de la original.

 Ejemplos

     .  Este ejemplo crea una matriz constante de tres elementos y, a
        continúa.ión, borra el segundo elemento. El tercer elemento se
        desplaza una posición y al nuevo tercer elemento se le asigna un
        valor NIL:

        LOCAL aMatriz
        aMatriz := { 1, 2, 3 }      //Resultado: aMatriz es
                                    // ahora { 1, 2, 3 }
        ADEL(aMatriz, 2)            //Resultado: aMatriz es
                                    // ahora { 1, 3, NIL }

 Ficheros:  La biblioteca asociada es CLIPPER.LIB.


ADIR()*
 Llena una serie de matrices con información del directorio
------------------------------------------------------------------------------
 Sintaxis

     ADIR([<cEspecFichero>],
        [<aNombresFichero>],
        [<aTama.os>],
        [<aFechas>],
        [<aHoras>],
        [<aAtributos>]) --> nFicheros

 Argumentos

     <cEspecFichero> es la especificación de la vía de los ficheros que
     se van a incluir en la b.squeda del directorio por defecto. Es una
     especificación de ficheros estándar, que permite incluir carácteres
     comod.n * y ? y referencias de unidades y vías. Si se omite, la
     especificación por defecto es *.*.

     <aNombresFichero> es la matriz que se va a llenar con los nombres de
     ficheros seleccionados con <cEspecFichero>. Cada elemento contiene el
     nombre y la extensión del fichero en forma de cadena de carácteres en
     mayúsculas.

     <aTama.os> es la matriz que se va a llenar con los tama.os de los
     ficheros correspondientes de la matriz <aNombresFichero>. Todos sus
     elementos son de tipo numérico.

     <aFechas> es la matriz que se va a llenar con las fechas de los
     ficheros correspondientes de la matriz <aNombresFichero>. Todos sus
     elementos son de tipo fecha.

     <aHoras> es la matriz que se va a llenar con las horas de los
     ficheros correspondientes de la matriz <aNombresFichero>. Todos sus
     elementos contienen una cadena de carácteres de formato: hh:mm:ss.

     <aAtributos> es la matriz que se va a rellenar con atributos de los
     ficheros correspondientes de la matriz <aNombresFichero>. Todosólos
     elementos son cadenas de carácteres. Si se especifica <aAtributos>,
     pueden incluirse ficheros ocultos, de sistema y de directorio junto a
     los ficheros normales. Si no se especifica <aAtributos>, solamente se
     incluyen ficheros normales.

 Devuelve

     ADIR() devuelve el número de ficheros seleccionables con el patr.n de
     directorios descrito por <cEspecFichero>.

 Descripción

     ADIR() es una función de matrices que realiza dos operación.s b.sicas.
     En primer lugar, devuelve el número de ficheros seleccionables con la
     especificación de ficheros. En segundo lugar, llena una serie de
     matrices con los nombres, tama.os, fechas, horas y atributos de los
     ficheros.

     ADIR() es una función de compatibilidad y, por tanto, su utilización no
     es recomendable. Puede sustituirse por la función DIRECTORY(), que
     devuelve toda la información de ficheros en una matriz multidimensiónal.

 Notas

     .  Directorios: Si se utiliza un argumento <aAtributos> y una
        <cEspecFichero> *.*, pueden incluirse directorios en
        <aNombresFichero>. En la matriz <aAtributos>, para indicar
        directorios se utiliza un atributo "D." Si se ejecuta ADIR() en un
        subdirectorio, las dos primeras entradas de <aNombresFichero> ser.n
        "." y "..", los alias de los directorios principal y actual
        respectivamente. Se indica también la fecha y hora de la .ltima
        actualizaci.n de un directorio, pero su tama.o es siempre cero.

 Ejemplos

     .  El ejemplo siguiente crea una matriz que va a contener los
        nombres de todos los ficheros (.txt) del directorio por defecto
        actual y, a continúa.ión, utiliza AEVAL() para listarlos en la
        consola:

           LOCAL aFicheros[ADIR("*.TXT")]
           ADIR("*.TXT", aFicheros)
           AEVAL(aFicheros, { |elemento| QOUT(elemento) })

 Ficheros: La biblioteca asociada es EXTEND.LIB.


AEVAL()
 Ejecuta un bloque de código en cada elemento de una matriz
------------------------------------------------------------------------------
 Sintaxis

     AEVAL(<aMatriz>, <bBloque>,
        [<nInicio>], [<nPosiciones>]) --> aMatriz

 Argumentos

     <aMatriz> es la matriz que se va a recorrer.

     <bBloque> es el bloque de código que se va a ejecutar en cada
     elemento encontrado.

     <nInicio> es el elemento inicial. Si no se especifica, el valor por
     defecto es el elemento uno.

     <nPosiciones> es el número de elementos que se van a procesar,
     contados desde <nInicio>. Si no se especifica, el valor por defecto es
     todos los elementos hasta el final de la matriz.

 Devuelve

     AEVAL() devuelve una referencia a <aMatriz>.

 Descripción

     AEVAL() es una función de matrices que eval.a un bloque de código en
     cada elemento de una matriz, pasando el valor y el índice del elemento
     como parámetros al bloque. El valor devuelto por el bloque se ignora. Se
     procesan todos los elementos de <aMatriz>, a no ser que se especifique
     <nInicio> o <nPosiciones>.

     AEVAL() no comprueba el contenido de los elementos de matriz que pasa al
     bloque. Se supone que el bloque correspondiente conoce el tipo de datos
     que hay en cada elemento.

     AEVAL() es similar a DBEVAL(), que aplica un bloque a cada registro de
     un fichero de base de datos. Al igual que DBEVAL(), AEVAL() puede
     utilizarse como primitiva para crear mandatos iterativos, tanto para
     estructuras de matriz simples como complejas.

     Si desea más información sobre la teor.a y la sintaxis de los bloques de
     código, consulte la secci.n Bloques de C.digo del capítulo Conceptos
     Básicos de la guía de Programación y Utilidades.

 Ejemplos

     .  El ejemplo siguiente utiliza AEVAL() para mostrar en pantalla
        una matriz de nombres y tama.os de fichero devueltos por la función
        DIRECTORY():

        #include "Directry.ch"
        //
        LOCAL aFicheros := DIRECTORY("*.dbf"), nTotal := 0
        AEVAL(aFicheros,;
           { | aFicheroDBF |;
              QOUT(PADR(aFicheroDBF[F_NAME], 10),    aFicheroDBF[F_SIZE]),;
              nTotal += aFicheroDBF[F_SIZE]);
           } )
        //
        ?
        ? "Bytes totales:", nTotal

     .  El ejemplo siguiente utiliza AEVAL() para crear una lista
        formada por los elementos seleccionados en una matriz
        multidimensiónal:

        #include "Directry.ch"
        //
        LOCAL aFicheros := DIRECTORY("*.dbf"), aNombres := {}
        AEVAL(aFicheros,;
           { | fichero | AADD(aNombres, fichero[F_NAME]) };
           )

     .  El ejemplo siguiente modifica el contenido de un elemento de
        matriz, dependiendo de una condición. Observe la utilización de los
        parámetros de bloque de código: */

        LOCAL aMatriz[6]
        AFILL(aMatriz,"anterior")
        AEVAL(aMatriz,;
        {|cValor,níndice| IF(cValor == "anterior",;
                          aMatriz[níndice] := "nuevo",)})

 Ficheros:  La biblioteca asociada es CLIPPER.LIB.


AFIELDS()*
 Llena matrices con la estructura del fichero actual de base de datos
------------------------------------------------------------------------------
 Sintaxis

     AFIELDS([<aNombresCampo>], [<aTipos>],
        [<aAnchuras>], [<aDecimales>]) --> nCampos

 Argumentos

     <aNombresCampo> es la matriz que se va a llenar con los nombres de
     campo. Todos sus elementos son cadenas de carácteres.

     <aTipos> es la matriz que se va a llenar con los tipos de campo de
     <aNombresCampo>. Todos sus elementos son cadenas de carácteres.

     <aAnchuras> es la matriz que se va a llenar con las anchuras de los
     campos de <aNombresCampo>. Todos sus elementos son de tipo numérico.

     <aDecimales> es la matriz que se va a llenar con el número de
     decimales definido para los campos de <aNombresCampo>. Todosólos
     elementos son de tipo numérico. Si el tipo del campo no es numérico, el
     elemento de <aDecimales> ser. cero.

 Devuelve

     AFIELDS() devuelve el número de campos o la longitud del argumento de
     matriz m.s corto, el que sea menor de los dos. Si no se especifican
     argumentos o no se est. utilizando un fichero de base de datos en el
     área de trabajo actual, AFIELDS() devuelve cero.

 Descripción

     AFIELDS() es una función de matrices que llena una serie de matrices (de
     atributos de estructura) con la estructura del fichero de base de datos
     actualmente abierto, un elemento de cada matriz por campo. AFIELDS()
     act.a como ADIR(), que llena una serie de matrices existentes con
     información. Para utilizar AFIELDS(), primero debe crear las matrices
     que van a contener la información de la estructura de la base de datos.
     Todas las matrices deben tener el mismo número de elementos que de
     campos (es decir, FCOUNT()). Una vez que se hayan creado las matrices de
     atributos de estructura, puede invocar AFIELDS() para rellenar estas
     matrices con la información de cada campo.

     Por defecto, AFIELDS() opera en el área de trabajo actual. Para operar
     en un área de trabajo no seleccionada, debe especificarla con una
     expresión de alias (consulte el ejemplo siguiente).

     AFIELDS() es una función de compatibilidad y, por tanto, su utilización
     no es recomendable. Puede sustituirse por DBSTRUCT(), que no requiere la
     existencia de matrices antes de la invocaci.n y devuelve una matriz
     multidimensiónal que contiene la estructura de fichero actual de base de
     datos.

 Ejemplos

     .  Este ejemplo muestra la forma de utilizar AFIELDS() y
        ACHOICE() simultáneamente para crear una lista de selecci.n de
        campos:

        USE Ventas NEW
        PRIVATE aNombresCampo[FCOUNT()]
        AFIELDS(aNombresCampo)
        @ 1, 0 TO 10, 10 DOUBLE
        nSeleccion := ACHOICE(2, 1, 9, 9, aNombresCampo)
        @ 12, 0 SAY IF(nSeleccion != 0, aNombresCampo[nSeleccion],;
                        "Ninguno seleccionado")
        RETURN

     .  El ejemplo siguiente utiliza AFIELDS() con una expresión de
        alias para llenar matrices con la estructura del fichero Ventas.dbf,
        abierto en un área de trabajo no seleccionada:

        LOCAL aNombresCampo, aTipos, aAnchuras, aDecimales
        USE Ventas NEW
        USE Cliente NEW
        //
        aNombresCampo := Ventas->(ARRAY(FCOUNT()))
        aTipos := Ventas->(ARRAY(FCOUNT()))
        aAnchuras := Ventas->(ARRAY(FCOUNT()))
        aDecimales := Ventas->(ARRAY(FCOUNT()))
        //
        Ventas->(AFIELDS(aNombresCampo, aTipos, ;
                 aAnchuras, aDecimales))

 Ficheros:  La biblioteca asociada es EXTEND.LIB.


AFILL()
 Rellena una matriz con un valor especificado
------------------------------------------------------------------------------
 Sintaxis

     AFILL(<aDestáno>, <expValor>,
        [<nInicio>], [<nPosiciones>]) --> aDestáno

 Argumentos

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

     <expValor> es el valor que se va a colocar en cada elemento de la matriz.
     Puede ser una expresión de cualquier tipo víaacute;lido.

     <nInicio> es la posición del primer elemento que se va a llenar. Si
     se omite este argumento, el valor por defecto es uno.

     <nPosiciones> es el número de elementos que se van a llenar
     comenzando por <nInicio>. Si se omite este argumento, los elementos se
     rellenan desde el elemento inicial hasta el final de la matriz.

 Devuelve

     AFILL() devuelve una referencia a <aDestáno>.

 Descripción

     AFILL() es una función de matrices que rellena la matriz especificada
     con un valor de cualquier tipo de datos (incluyendo matrices, bloques de
     código o valores NIL), asignando <expValor> a cada elemento de matriz
     dentro del rango especificado.

     .Advertencia! AFILL() no puede utilizarse para llenar matrices
     multidimensiónales. CA-Clipper crea las matrices las multidimensiónales
     anidando unas matrices dentro de otras. La utilización de AFILL() con
     una matriz multidimensiónal sobreescribe las submatrices que se utilizan
     para las otras dimensiónes de la matriz.

 Ejemplos

     .  El ejemplo siguiente crea una matriz de tres elementos, la
        rellena con el valor l.gico (.F.) y, finalmente, a los elementos de
        las posiciónes dos y tres les asigna el valor verdadero (.T.):

        LOCAL aLogico[3]
        //Resultado: aLogico es { NIL, NIL, NIL }

        AFILL(aLogico, .F.)
        //Resultado: aLogico es { .F., .F., .F. }
        AFILL(aLogico, .T., 2, 2)
        //Resultado: aLogico es { .F., .T., .T. }

 Ficheros:  La biblioteca asociada es CLIPPER.LIB.


AINS()
 Inserta un elemento NIL en una matriz
------------------------------------------------------------------------------
 Sintaxis

     AINS(<aDestáno>, <nPosici.n>) --> aDestáno

 Argumentos

     <aDestáno> es la matriz en la que se va a insertar el nuevo
     elemento.

     <nPosici.n> es la posición en la que se va a insertar el nuevo
     elemento.

 Devuelve

     AINS() devuelve una referencia a la matriz destáno, <aDestáno>.

 Descripción

     AINS() es una función de matrices que inserta un nuevo elemento en una
     matriz especificada. El elemento reci.n insertado ser. de tipo NIL hasta
     que se le asigne un nuevo valor. Despu.s de la inserci.n, el último
     elemento de la matriz se descarta y todos los elementos que van detrás
     del elemento nuevo se desplazan una posición.

     .Advertencia! AINS() debe utilizarse con cuidado en matrices
     multidimensiónales. En CA-Clipper las matrices multidimensiónales se
     crean anidando unas matrices dentro de otras. La utilización de AINS()
     en una matriz multidimensiónal elimina el último elemento de la matriz
     y, si dicho elemento es una submatriz, se pierden una o más dimensiónes.
     Para insertar una nueva dimensión en una matriz, a.ada primero un nuevo
     elemento al final de la matriz mediante AADD() o ASIZE() antes de
     utilizar AINS().

 Ejemplos

     .  El ejemplo siguiente muestra el resultado de la utilización de
        AINS() en una matriz:

        LOCAL aMatriz
        aMatriz := { 1, 2, 3 }      //Resultado: aMatriz es
                                    // ahora { 1, 2, 3 }
        AINS(aMatriz, 2)            //Resultado: aMatriz es
                                    // ahora { 1, NIL, 2 }

 Ficheros:  La biblioteca asociada es CLIPPER.LIB.


ALERT()
 Muestra en pantalla un panel de diálogo modal sencillo
------------------------------------------------------------------------------
 Sintaxis

     ALERT( <cMensaje>, [<aOpciones>] ) --> nSelecci.n

 Argumentos

     <cMensaje> es el texto del mensaje, mostrado y centrado en el cuadro
     de advertencia. Si el mensaje contiene uno o m.s signos de punto y coma,
     el texto que va detrás de estos signos se centra en las líneas
     siguientes del panel de diálogo.

     <aOpciones> define una lista de hasta cuatro posibles respuestas al
     panel de diálogo.

 Devuelve

     ALERT() devuelve un valor numérico que indica la opción escogida. Si se
     pulsa la tecla Esc, el valor devuelto es cero.

 Descripción

     La función ALERT() crea un panel de diálogo modal sencillo. Es .til para
     manejadores de error y otras funciónes de "pausa". El usuario puede
     responder moviendo una barra resaltada y pulsando las teclas Intro o
     Barra espaciadora, o pulsando la tecla correspondiente a la primera
     letra de la opción. Si no se especifica <aOpciones>, sólo aparece la
     opción "OK".

     ALERT() es sensible a la utilización del sistema de entrada/salida de
     pantalla completa de CA-Clipper. Si no se utiliza el sistema de pantalla
     completa, ALERT() utiliza la entrada/salida estándar y muestra el
     mensaje y las opciónes en estilo de teleimpresora (es decir, 80
     columnas, sin saltos de línea autom.ticos y cada línea terminada con un
     retorno de carro/salto de línea).

 Ejemplos

     .  El ejemplo de la p.gina siguiente muestra la utilización de un
        panel de advertencia . Primero se define la matriz de las opciónes,
        la función ALERT() recoge la selecci.n del usuario y, finalmente,
        ésta se procesa con una estructura de control DO CASE...ENDCASE:

        #define AL_SAVE            1
        #define AL_CANCEL          2
        #define AL_CONT            3

        // Define una matriz de opciónes
        aOpciones := {"Salvar", "No Salvar", "Continuar"}

        // Muestra el panel de diálogo y recoge la
        // selecci.n del usuario
        nSeleccion := ALERT("El fichero ha sido modificado ..", aOpciones)

        // Procesa la selecci.n del usuario
        DO CASE
        CASE nSeleccion == AL_SAVE
           ? "Salvar"
        CASE nSeleccion == AL_CANCEL
           ? "No Salvar"
        CASE nSeleccion == AL_CONT
           ? "Continuar"
        OTHERWISE
           ? "Escape"
        ENDCASE
        //
        RETURN

 Ficheros:  La biblioteca asociada es CLIPPER.LIB.


ALIAS()
 Devuelve el alias del área de trabajo especificada
------------------------------------------------------------------------------
 Sintaxis

     ALIAS([<nAreaTrabajo>]) --> cAlias

 Argumentos

     <nAreaTrabajo> es cualquier número de área de trabajo.

 Devuelve

     ALIAS() devuelve el alias del área de trabajo, especificado como una
     cadena de carácteres. Si no se indica <nAreaTrabajo>, se devuelve el
     alias del área de trabajo actual. Si no se est. utilizando ningún
     fichero de base de datos en el área de trabajo especificada, ALIAS()
     devuelve una cadena nula ("").

 Descripción

     ALIAS() es una función de base de datos que determina el alias del .rea
     de trabajo especificada. Un alias es el nombre asignado a un .rea de
     trabajo cuando utiliza un fichero de base de datos. El nombre asignado
     realmente es el nombre del fichero de base de datos o un nombre asignado
     explícitamente con la cláusula ALIAS del mandato USE.

     ALIAS() es la función inversa de SELECT(). ALIAS() recibe un número de
     área de trabajo y devuelve el alias. SELECT() recibe el alias y devuelve
     el número del área de trabajo.

     .  El ejemplo siguiente devuelve el nombre del área de trabajo
        seleccionada:

        USE Fichero1 NEW ALIAS Prueba1
        nAreaAnterior := SELECT()
        USE Fichero2 NEW ALIAS Prueba2
        ? ALIAS( nAreaAnterior )            // Devuelve Prueba1

 Ficheros:  La biblioteca asociada es CLIPPER.LIB.



ALLTRIM()
 Suprime los espacios en blanco iniciales y finales de una cadena de
 carácteres
------------------------------------------------------------------------------
 Sintaxis

     ALLTRIM(<cCadena>) --> cSuprCadena

 Argumentos

     <cCadena> es la expresión de carácteres que se va a recortar.

 Devuelve

     ALLTRIM() devuelve una cadena de carácteres en la que se han eliminado
     los espacios iniciales y finales en blanco.

 Descripción

     ALLTRIM() es una función de carácteres que elimina tanto los espacios
     iniciales como los finales de una cadena. Está relacionada con LTRIM() y
     RTRIM(), que eliminan los espacios iniciales y finales, respectivamente.
     Las funciónes inversas de ALLTRIM(), LTRIM() y RTRIM() son PADC(), PADL() y
     PADR(), que centran, justifican a la izquierda o justifican a la derecha
     cadenas de carácteres, rellen.ndolas con carácteres de relleno.

 Ejemplos

     .  El ejemplo siguiente crea una cadena con espacios iniciales y
        finales en blanco y luego los elimina con ALLTRIM():

        cCadena := SPACE(10) + "cadena" + SPACE(10)
        ? LEN(cCadena)                     //Resultado: 26
        ? LEN(ALLTRIM(cCadena))            //Resultado: 6

 Ficheros:  La biblioteca asociada es EXTEND.LIB.



ALTD()
 Invoca al depurador de CA-Clipper
------------------------------------------------------------------------------
 Sintaxis

     ALTD([<nAcción>]) --> NIL

 Argumentos

     <nAcción> define la acci.n que realiza ALTD() cuando se invoca. A
     continúa.ión se da la una lista completa de los valores de <nAcción> y
     sus resultados:

     Acciónes de ALTD()
     ------------------------------------------------------------------------
     Argumento     Acción
     ------------------------------------------------------------------------
     Ninguno       Invoca al depurador si est. habilitado
     0             Desactiva Alt-D
     1             Activa Alt-D
     Otro          Ninguna acci.n
     ------------------------------------------------------------------------

 Devuelve

     ALTD() siempre devuelve NIL.

 Descripción

     ALTD() realiza distintas acciones, dependiendo de su argumento, tal como
     se indica en la tabla anterior. Si desea más información sobre la
     utilización del depurador, consulte el capítulo El Depurador de
     CA-Clipper de la guía de Programación y Utilidades.

 Ejemplos

     .  El ejemplo siguiente muestra una serie de constantes
        declaradas que pueden utilizarse como argumentos de ALTD() antes de
        invocar al depurador de programas:

        #define ALTD_DISABLE     0
        #define ALTD_ENABLE      1
        //
        ALTD(ALTD_ENABLE)

 Ficheros:  La biblioteca asociada es CLIPPER.LIB.


ARRAY()
 Crea una matriz de una longitud especificada, sin inicializar
------------------------------------------------------------------------------
 Sintaxis

     ARRAY(<nElementos> [, <nElementos>...]) --> aMatriz

 Argumentos

     <nElementos> es el número de elementos de la dimensión especificada.
     El número máximo de elementos de una dimensión es 4096. Las matrices de
     CA-Clipper pueden tener un número de dimensiónes ilimitado.

 Devuelve

     ARRAY() devuelve una matriz con las dimensiónes especificadas.

 Descripción

     ARRAY() es una función de matrices que devuelve una matriz no
     inicializada con el número de elementos y dimensiónes especificado. Si
     se especifica m.s de un argumento <nElementos>, se crear. una matriz
     multidimensiónal con un número de dimensiónes igual al número de
     argumentos <nElementos> especificado. Si alg.n argumento <nElementos> es
     una matriz, se crea una matriz anidada.

     En CA-Clipper, existen varias formas de crear una matriz. Puede
     declararse utilizando una sentencia LOCAL o STATIC; también puede
     crearse con una declaración PRIVATE o PUBLIC; puede asignarse una matriz
     en forma literal a una variable existente o puede usarse la función
     ARRAY(). ARRAY() tiene la ventaja de que permite crear matrices dentro
     de expresiónes o bloques de código.

 Ejemplos

     .  El ejemplo siguiente crea una matriz unidimensiónal de cinco
        elementos utilizando la función ARRAY(). Luego, muestra la acci.n
        equivalente asignando una matriz literal con valores NIL:

        aMatriz := ARRAY(5)
        aMatriz := { NIL, NIL, NIL, NIL, NIL }

     .  El ejemplo siguiente muestra tres sentencias distintas que
        crean la misma matriz multidimensiónal:

        aMatriz := ARRAY(3, 2)
        aMatriz := { {NIL, NIL}, {NIL, NIL}, {NIL, NIL} }
        aMatriz := { ARRAY(2), ARRAY(2), ARRAY(2) }

     .  El ejemplo siguiente crea una matriz anidada multidimensiónal:

        aMatriz := ARRAY(3, {NIL,NIL})

 Ficheros:  La biblioteca asociada es CLIPPER.LIB.


ASC()
 Convierte un carácter en su valor ASCII
------------------------------------------------------------------------------
 Sintaxis

     ASC(<cExp>) --> nC.digo

 Argumentos

     <cExp> es la expresión de carácteres que va a convertirse en un
     número.

 Devuelve

     ASC() devuelve un valor numérico entero entre 0 y 255 que representa el
     valor ASCII de <cExp>.

 Descripción

     ASC() es una función de conversión de carácteres que devuelve el valor
     ASCII del carácter situado m.s a la izquierda de una cadena de
     carácteres. ASC() se utiliza fundamentalmente en expresiónes que
     requieran cálculos numéricos con el valor ASCII de un carácter. CHR() y
     ASC() son funciónes inversas.

 Ejemplos

     .  Los ejemplos siguientes muestran distintos resultados de
        ASC():

        ? ASC("A")                     //Resultado: 65
        ? ASC("Apple")                 //Resultado: 65
        ? ASC("a")                     //Resultado: 97
        ? ASC("Z") - ASC("A")          //Resultado: 25
        ? ASC("")                      //Resultado: 0

 Ficheros:  La biblioteca asociada es CLIPPER.LIB.


ASCAN()
 Examina una matriz, buscando un valor determinado o hasta que un bloque
 devuelva el valor verdadero (.T.)
------------------------------------------------------------------------------
 Sintaxis

     ASCAN(<aDestáno>, <expB.squeda>,
        [<nInicio>], [<nPosiciones>]) --> nParadaEn

 Argumentos

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

     <expB.squeda> es el valor de tipo simple que se va a buscar o un
     bloque de código. Si <expB.squeda> es un valor simple, puede ser de tipo
     carácter, fecha, l.gico o numérico.

     <nInicio> es el elemento donde se inicia la b.squeda. Si no se
     especifica este argumento, la posición inicial por defecto es uno.

     <nPosiciones> es el número de elementos que se van a examinar a
     partir de la posición inicial. Si no se especifica este argumento, se
     examinan todos los elementos, desde el elemento inicial hasta el final
     de la matriz.

 Devuelve

     ASCAN() devuelve un valor numérico que representa la posición en la
     matriz del último elemento examinado. Si <expB.squeda> es un valor
     simple, ASCAN() devuelve la posición del primer elemento que coincida, o
     cero si no se encuentra ningúno. Si <expB.squeda> es un bloque de
     código, ASCAN() devuelve la posición del elemento donde el bloque
     devuelve verdadero (.T.).

 Descripción

     ASCAN() es una función de matrices que busca un valor especificado en
     una matriz. funcióna como SEEK cuando se busca un valor simple. El valor
     de <expB.squeda> se compara con los elementos de la matriz de destáno,
     empezando por el carácter situado m.s a la izquierda de cada elemento y
     continúa.do hasta que no queden m.s carácteres en <expB.squeda>. Si no
     encuentra ningúna coincidencia, ASCAN() continúa.en el siguiente
     elemento de la matriz.

     Como ASCAN() utiliza el operador igual (=) para las comparaciones, puede
     distinguir el estado de EXACT. Si EXACT est. activado, el elemento de
     matriz destáno debe ser exactamente igual que el resultado de
     <expB.squeda> para que sean coincidentes.

     Si el argumento <expB.squeda> es un bloque de código, ASCAN() examina la
     matriz <aDestáno> ejecutando el bloque en todos los elementos a los que
     se accede. A medida que encuentra cada elemento, ASCAN() pasa como
     argumento el valor del elemento al bloque de código y ejecuta una
     función EVAL() en el bloque. La operación.de b.squeda se detiene cuando
     el bloque de código devuelve verdadero (.T.) o cuando ASCAN() llega al
     último elemento de la matriz.

 Ejemplos

     .  El ejemplo siguiente muestra el examen de una matriz de tres
        elementos que contiene valores simples, con un bloque de código como
        criterio de b.squeda. El criterio del bloque de código muestra la
        forma de realizar una b.squeda que diferencie mayúsculas y
        minúsculas:

        aMatriz := { "Tom.s", "Mar.a", "Susana" }
        ? ASCAN(aMatriz, "Mar.a")               //Resultado: 2
        ? ASCAN(aMatriz, "mar.a")               //Resultado: 0
        //
        ? ASCAN(aMatriz, { |x| UPPER(x) ;
              == "MARIA" })                     //Resultado: 2

     .  El ejemplo siguiente muestra una b.squeda de apariciones
        m.ltiples de un argumento tras encontrar una coincidencia:

                  LOCAL aMatriz := { "Tom.s", "Mar.a", "Susana",;
                                        "Mar.a" }, nInicio := 1

        //
        // Obtiene la posición del último elemento de la matriz
        nEnFin := LEN(aMatriz)
        DO WHILE (nPos := ASCAN(aMatriz, "Mar.a", ;
                        nInicio)) > 0
           ? nPos, aMatriz[nPos]
           //
           // Obtiene la nueva posición inicial y
           // comprueba la condición l.mite
           IF (nInicio := ++nPos) > nEnFin
              EXIT
           ENDIF
        ENDDO

     .  El ejemplo siguiente examina una matriz bidimensiónal
        utilizando un bloque de código. Observe que el parámetro aVal del
        bloque de código es una matriz:

        LOCAL aMat:={}
        CLS
        AADD(aMat,{"uno","dos"})
        AADD(aMat,{"tres","cuatro"})
        AADD(aMat,{"cinco","seis"})
        ? ASCAN(aMat, {|aVal| aVal[2] == "cuatro"})   // Resultado: 2

 Ficheros:  La biblioteca asociada es CLIPPER.LIB.


ASIZE()
 Amplía o reduce una matriz
------------------------------------------------------------------------------
 Sintaxis

     ASIZE(<aDestáno>, <nLongitud>) --> aDestáno

 Argumentos

     <aDestáno> matriz que se va a ampliar o reducir.

     <nLongitud> es el nuevo tama.o de la matriz.

 Devuelve

     ASIZE() devuelve una referencia a la matriz destáno, <aDestáno>.

 Descripción

     ASIZE() es una función de tratamiento de matrices que cambia la longitud
     real de la matriz <aDestáno>. La matriz se acorta o se alarga hasta que
     coincida con la longitud especificada. Si la matriz se acorta, los
     elementos que se encuentren al final de la misma se pierden. Si la
     matriz se alarga, se a.aden nuevos elementos al final de la matriz y se
     les asigna el valor NIL.

     ASIZE() es similar a AADD(), que a.ade un nuevo elemento al final de una
     matriz y, si se desea, le asigna un nuevo valor. Recuerde que ASIZE() es
     diferente a AINS() y ADEL(), que no cambian realmente la longitud de la
     matriz.

 Ejemplos

     .  Los ejemplos siguientes muestran la adici.n de nuevos
        elementos y el borrado de elementos existentes:

        aMatriz := { 1 }       //Resultado: aMatriz es { 1 }
        ASIZE(aMatriz, 3)      //Resultado: aMatriz es { 1, NIL, NIL }
        ASIZE(aMatriz, 1)      //Resultado: aMatriz es { 1 }

 Ficheros:  La biblioteca asociada es CLIPPER.LIB.


ASORT()
 Ordena una matriz
------------------------------------------------------------------------------
 Sintaxis

     ASORT(<aDestáno>, [<nInicio>],
        [<nPosiciones>], [<bOrden>]) --> aDestáno

 Argumentos

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

     <nInicio> es el primer elemento que se va a ordenar. Si no se
     especifica, la posición inicial por defecto es uno.

     <nPosiciones> es el número de elementos que se van a ordenar. Si no
     se especifica, se ordenan todos los elementos de la matriz desde el
     elemento inicial.

     <bOrden> es un bloque de código opciónal que se utiliza para
     determinar el criterio de ordenación. Si no se especifica, el criterio
     por defecto es ascendente.

 Devuelve

     ASORT() devuelve una referencia a la matriz <aDestáno>.

 Descripción

     ASORT() es una función de matrices que clasifica, total o parcialmente,
     una matriz que contiene elementos del mismo tipo de datos. Los tipos de
     datos que pueden ordenarse son carácteres, fechas, valores lógicos y
     numéricos.

     Si no se especifica el argumento <bOrden>, el orden por defecto es
     ascendente. Los elementos con valores bajos se sit.an al principio de la
     matriz (primer elemento) y los elementos con valores altos se colocan al
     final de la misma (último elemento).

     Si se especifica un argumento <bOrden> en forma de bloque, el bloque se
     eval.a para determinar el orden de clasificaci.n. Cada vez que se eval.a
     el bloque, se le pasan como parámetros dos elementos de la matriz
     destáno. El bloque devuelve verdadero (.T.) si los elementos están en el
     orden correcto. Esta opción permite crear un criterio de ordenación
     descendente o cualquier otro. Consulte los ejemplos siguientes.

     Al ordenarse, las cadenas de carácteres se sit.an secuencialmente seg.n
     el valor de su código ASCII, los valores lógicos se clasifican con falso
     (.F.) como valor bajo; los valores de fecha se clasifican
     cronol.gicamente; y los valores numéricos se clasifican por su magnitud.

     Nota: Como CA-Clipper crea las matrices multidimensiónales anidando
     submatrices dentro de otras matrices, ASORT() no puede ordenar
     directamente una matriz multidimensiónal. Para ordenar una matriz
     anidada, debe especificarse un bloque de código que permita manejar
     adecuadamente submatrices.

 Ejemplos

     .  El ejemplo siguiente crea una matriz de cinco elementos sin
        ordenar, la clasifica en orden ascendente y, a continúa.ión, la
        clasifica en orden descendente con un bloque de código:

        aMatriz := { 3, 5, 1, 2, 4 }
        ASORT(aMatriz)
        //Resultado: { 1, 2, 3, 4, 5 }

        ASORT(aMatriz,,, { |x, y| x > y })
        //Resultado: { 5, 4, 3, 2, 1 }


     .  El ejemplo siguiente ordena una matriz de cadenas de
        carácteres en orden ascendente, sin diferenciar mayúsculas o
        minúsculas. Para ello, utiliza un bloque de código que convierte los
        elementos en mayúsculas antes de compararlos:

        aMatriz := { "Federico", "Catalina", "ALBERTO", "amigo" }
        ASORT(aMatriz,,, { |x, y| UPPER(x) < UPPER(y) })

     .  El ejemplo siguiente clasifica una matriz anidada utilizando
        el segundo elemento de cada submatriz:

        aChicos := { {"Mar.a", 14}, {"Jos.", 23}, {"Arturo", 16} }
        aClasifChicos := ASORT(aChicos,,, { |x, y| x[2] < y[2] })

        Resultado:

        { {"Mar.a", 14}, {"Arturo", 16}, {"Jos.", 23} }

 Ficheros:  La biblioteca asociada es EXTEND.LIB.


AT()
 Devuelve la posición de una subcadena dentro de una cadena de carácteres
------------------------------------------------------------------------------
 Sintaxis

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

 Argumentos

     <cB.squeda> es la subcadena de carácteres que se va a buscar.

     <cDestáno> es la cadena de carácteres en la que se realiza la
     b.squeda.

 Devuelve

     AT() devuelve la posición de la primera aparici.n de <cB.squeda> dentro
     de <cDestáno>, como valor numérico entero. Si no se encuentra
     <cB.squeda>, AT() devuelve cero.

 Descripción

     AT() es una función de tratamiento de carácteres que se utiliza para
     determinar la posición de la primera aparici.n de una subcadena dentro
     de otra cadena. Si sólo necesita saber si una subcadena se encuentra
     dentro de otra, utilice el operador $. Para encontrar la .ltima
     aparici.n de una cadena dentro de otra, utilice RAT().

 Ejemplos

     .  Los ejemplos siguientes muestran la utilización normal de
        AT():

        ? AT("a", "abcde")                    //Resultado: 1
        ? AT("bcd", "abcde")                  //Resultado: 2
        ? AT("a", "bcde")                     //Resultado: 0

     .  El ejemplo siguiente divide una cadena de carácteres bas.ndose
        en la posición de una coma en la cadena destáno:

        cDestáno := "L.pez, Luisa"
        ? SUBSTR(cDestáno, 1, AT(",", cDestáno) - 1)
        //Resultado: L.pez

        ? SUBSTR(cDestáno, AT(",", cDestáno) + 2)
        //Resultado: Luisa

 Ficheros:  La biblioteca asociada es CLIPPER.LIB.



ATAIL()
 Devuelve el último elemento de una matriz
------------------------------------------------------------------------------
 Sintaxis

     ATAIL(<aMatriz>) --> Elemento

 Argumentos

     <aMatriz> es la matriz que se va a tratar.

 Devuelve

     ATAIL() devuelve un valor o una referencia a una matriz u objeto. La
     matriz no se modifica.

 Descripción

     ATAIL() es una función de matrices que devuelve el elemento de una
     matriz que tenga el número m.s alto. Puede utilizarse en las
     aplicaciónes como forma abrevíada de <aMatriz>[LEN(<aMatriz>)] cuando
     necesite obtener el último elemento de una matriz.

 Ejemplos

     .  El ejemplo siguiente crea una matriz literal y devuelve el
        último elemento de la misma:

        aMatriz := {"a", "b", "c", "d"}
        ? ATAIL(aMatriz)                     //Resultado: "d"

 Ficheros:  La biblioteca asociada es CLIPPER.LIB.

Solo personas registradas pueden poner comentarios