GUÍA DE SENTENCIAS CLIPPER

ANNOUNCE
 Declara un identificador de módulo
------------------------------------------------------------------------------
 Sintaxis

     ANNOUNCE <idM.dulo>

 Argumentos

     <idM.dulo> es el nombre de un identificador de módulo.

 Descripción

     ANNOUNCE es una sentencia que define un identificador de módulo. Los
     enlazadores útilizan m.s tarde este identificador para las sentencias
     REQUEST pendientes. ANNOUNCE y REQUEST sirven de mecanismo de manejo de
     módulos de aplicación (ficheros .prg).

     Las sentencias ANNOUNCE deben especificarse en el módulo fuente antes
     que cualquier sentencia ejecutable. Un fichero fuente (.prg) sólo puede
     tener un identificador de módulo; todas las declaraciónes ANNOUNCE
     posteriores generan una advertencia de compilador y se ignoran. Los
     identificadores de módulo deben ser exclusivos y no deben duplicar el
     nombre de ningún procedimiento o función del fichero fuente (.prg).

 Ejemplos

     .  El ejemplo siguiente muestra una declaración ANNOUNCE:

        ANNOUNCE InicPerson

        INIT PROCEDURE MiInic
           ? "Industrias Hipot.ticas S.A."
           RETURN

        El módulo de programa anterior, InicPerson, debe compilarse con la
        opción /N. M.s tarde, este programa puede direccionarse en el código
        fuente de cualquier otro módulo mediante una sentencia REQUEST:

        REQUEST InicPerson

        que hace que el módulo InicPerson se enlace en el fichero (.exe)
        resultante.

BEGIN SEQUENCE
 Define una secuencia de sentencias que se interrumpe con un BREAK
------------------------------------------------------------------------------
 Sintaxis

     BEGIN SEQUENCE
        <sentencias>...
     [BREAK [<exp>]]
        <sentencias>...
     [RECOVER [USING <idVar>]]
        <sentencias>...
     END [SEQUENCE]

 Argumentos

     BREAK <exp> bifurca la ejecución a la sentencia inmediatamente
     después del RECOVER m.s cercano, si se ha especificado uno, o de la
     sentencia END SEQUENCE en caso contrario. <exp> es el valor de retorno,
     que se almacena en la <idVar> especificada en la cláusula USING de la
     sentencia RECOVER.

     RECOVER USING <idVar> define un punto de recuperaci.n en la
     estructura SEQUENCE. El control pasa a este punto después de una
     sentencia BREAK. Si se especifica la cláusula USING <idVar>, esta
     variable recibe el valor de retorno de la sentencia BREAK, que suele ser
     un objeto de error.

     END define el punto final de la estructura SEQUENCE. Despu.s de un
     BREAK, el control se bifurca a la primera sentencia después del END si
     no se ha especificado una secuencia RECOVER.

 Descripción

     BEGIN SEQUENCE...END es una estructura de control que se utiliza para el
     manejo de excepciones y errores de ejecución. Delimita un bloque de
     sentencias que incluye todos procedimientos y funciónes invocados. Si se
     encuentra un BREAK en el bloque de sentencias comprendido entre BEGIN
     SEQUENCE y el RECOVER correspondiente, el control se bifurca a la
     sentencia inmediatamente después de RECOVER. Si no se especifica una
     sentencia RECOVER, el control pasa a la sentencia después de END y
     finaliza la estructura SEQUENCE. Si el control llega a la sentencia
     RECOVER sin encontrar antes un BREAK, pasa a la sentencia después del
     END correspondiente.

     La sentencia RECOVER puede recibir, opciónalmente, un parámetro pasado
     por la sentencia BREAK como valor de retorno. Normalmente es un objeto
     error, generado y devuelto por el bloque actual de manejo de errores
     definido con ERRORBLOCK(). Si se devuelve un objeto de error, pueden
     envíarse mensajes para solicitar información sobre el error. Con esta
     información, los errores de ejecución pueden manejarse en el mismo
     contexto de la operación. en vez de en el manejador actual de errores de
     ejecución. Consulte el ejemplo siguiente.

     En una estructura SEQUENCE existen algunas restricciones sobre las
     sentencias permitidas entre BEGIN SEQUENCE y RECOVER. No pueden
     ejecutarse sentencias RETURN, LOOP o EXIT. Dentro del bloque de
     sentencias de RECOVER, no obstante, pueden ejecutarse sentencias LOOP,
     EXIT, BREAK o RETURN, ya que la estructura SEQUENCE ha finalizado
     pr.cticamente en este punto. La utilización de un LOOP en el bloque de
     sentencias de RECOVER permite volver a ejecutar el bloque de sentencias
     de SEQUENCE. Consulte el ejemplo siguiente.

     Las estructuras SEQUENCE son bastante flexibles. Pueden anidarse y puede
     haber varias en un mismo procedimiento o función. Si se especifica m.s
     de una estructura SEQUENCE, cada una debe delimitar una operación.bien
     definida.

     Si desea más información sobre los objetos de error, consulte la clase
     Error en este capítulo.

 Ejemplos

     .  El siguiente fragmento de código muestra una estructura
        SEQUENCE en la que aparece una sentencia BREAK dentro del
        procedimiento actual:

        BEGIN SEQUENCE
           <sentencias>...
           IF lCondBreak
              BREAK
           ENDIF
        RECOVER
           <sentencias de recuperaci.n>...
        END

        <sentencias de recuperaci.n>...

     .  El ejemplo siguiente muestra un manejador de errores que
        devuelve un objeto de error a la variable especificada en la cláusula
        USING de la sentencia RECOVER:

        LOCAL objLocal, búltimoManejador
        //
        // Salvar el manejador actual y crear
        // un nuevo manejador de errores
        búltimoManejador := ERRORBLOCK({ |objErr| ;
              MiManejador(objErr, .T.) })
        //
        BEGIN SEQUENCE
           .
           . <operación.que puede fallar>
           .
        RECOVER USING objLocal
           //
           // Envíar mensajes a objLocal y manejar el error
           ? "Error: "
           IF objLocal:genCode != 0
              ?? objLocal:description
           ENDIF
           .
           .
           .
        END
        //
        // Restablecer el manejador de errores anterior
        ERRORBLOCK( búltimoManejador )

        FUNCTION MiManejador( objError, lManejadorLocal)
           //
           // Manejar los erroresólocalmente devolviendo
           // el objeto de error
           IF lManejadorLocal
              BREAK objError
           ENDIF
           .
           . <otras sentencias para manejar el error>
           .
           RETURN NIL

     .  El ejemplo siguiente vuelve a ejecutar el bloque de sentencias
        de SEQUENCE por medio de un LOOP en el bloque de sentencias de
        RECOVER:

        DO WHILE .T.
           BEGIN SEQUENCE
              .
              . <operación.que puede fallar>
              .
           RECOVER
              IF ImprimirRecup()
                 LOOP   // Repetir el bloque de sentencias SEQUENCE
              ENDIF
           END
           EXIT         // Salir de la operación.        ENDDO

DECLARE*
 Crea e inicializa matrices y variables de memoria privadas
------------------------------------------------------------------------------
 Sintaxis

     DECLARE <identificador> [[:= <inicializador>], ... ]

 Argumentos

     <identificador> es el nombre de una variable privada o matriz que se
     va a crear. Si <identificador> va seguido por corchetes ([ ]), se crea
     una matriz. En tal caso, la sintaxis para especificar el número de
     elementos para cada dimensión es matriz[<nElementos>, <nElementos2>,...]
     o matriz[<nElementos>][<nElementos2>]... El número máximo de elementos
     por dimensión es 4096.

     <inicializador> es la asignación opciónal de un valor a una nueva
     variable privada. La expresión de <inicializador> para una variable
     privada est. formada por el operador de asignación en línea (:=) seguido
     por cualquier expresión víaacute;lida de CA-Clipper, incluyendo una matriz
     literal. Si no se especifica ningún <inicializador> explícito, la
     variable recibe un valor inicial de NIL. En el caso de una matriz, cada
     uno de sus elementos tiene un valor NIL. No pueden asignarse valores a
     los elementos de una matriz mediante un <inicializador>.

     DECLARE puede crear e inicializar, opciónalmente, una lista de matrices
     de variables, separando las definiciónes con comas.

 Descripción

     DECLARE es una sentencia de compatibilidad y es sin.nima de la sentencia
     PRIVATE. No se recomienda su utilización general. PRIVATE debe
     utilizarse en todos los casos. Consulte PRIVATE si desea m.s
     información.

DO*
 Llama a un procedimiento
------------------------------------------------------------------------------
 Sintaxis

     DO <idProcedimiento> [WITH <lista argumentos>]

 Argumentos

     <idProcedimiento> es el nombre del procedimiento o función definida
     por el usuario que va a ejecutarse.

     <lista argumentos> WITH especifica un máximo de 128 argumentos,
     separados por comas, que se van a pasar a <idProcedimiento>. Cada
     argumento puede ser una variable sencilla, un campo, una matriz, un
     elemento de una matriz, una expresión o un objeto. Los argumentos pueden
     omitirse o dejarse al final de la lista.

 Descripción

     La sentencia DO llama a un procedimiento o función pasando,
     opciónalmente, argumentos a la rutina invocada. Realiza la misma acci.n
     que una función o procedimiento especificado en una línea, con la
     excepci.n de que las variables que no sean de campo se pasan por
     referencia por defecto. Para pasar una variable de campo como argumento,
     debe encerrarla entre paréntesis, a menos que la declare con una
     sentencia FIELD o con un alias.

     En CA-Clipper, no es necesario que el número de argumentos especificados
     sea igual al de parámetros especificados en el procedimiento invocado.
     Si el número de argumentos es menor que el número de parámetros, las
     variables de parámetros sin argumentos correspondientes se inicializan
     con un valor NIL. Del mismo modo, si se omite un argumento de la <lista
     argumentos>, dejando un lugar vac.o con una coma, el argumento
     correspondiente se inicializa con un valor NIL. Si desea conocer la
     posición del último argumento pasado en la <lista argumentos>, utilice
     PCOUNT(). Para saber si se ha omitido un argumento, compare el parámetro
     recibido con el valor NIL.

     Además de invocar a un procedimiento o función, DO tiene un efecto sobre
     la compilación si compila el módulo fuente actual sin la opción /M. Si
     el compilador de CA-Clipper encuentra una sentencia DO y el
     procedimiento especificado no se ha compilado todavía, el compilador
     busca el fichero (.prg) en el directorio actual con el mismo nombre y lo
     compila. Si no se encuentra dicho fichero, el procedimiento invocado se
     supone externo y se a.ade una referencia al fichero objeto (.OBJ). En el
     momento del enlace, el enlazador busca en otros ficheros objeto y
     bibliotecas con esta referencia externa.

     En CA-Clipper, DO es una sentencia de compatibilidad y su utilización no
     es recomendable. Es preferible hacer una llamada al procedimiento o
     función en una línea independiente. Puesto que en la convenci.n de
     llamadas preferible los parámetros se pasan normalmente por valor, si
     desea pasar un argumento por referencia debe precederlo con el operador
     pasar por referencia (@). Si utiliza las sentencias DO para hacer m.s
     legible una llamada de procedimientos, los mandatos definidos con una
     directiva #command ofrecen una mayor legibilidad sin sacrificar la
     seguridad de las variables pasadas como parámetros.

     Si desea más información sobre la forma de paso de parámetros, consulte
     el apartado funciónes y Procedimientos del capítulo Conceptos Básicos de
     la gu.a Programaci.n y Utilidades.

 Ejemplos

     .  Este ejemplo ejecuta un procedimiento sin parámetros:

        DO InfoCuentas
        InfoCuentas()                             // M.todo preferible

     .  Este ejemplo ejecuta un procedimiento pasando dos constantes:

        DO InfoTrimestral WITH "2.", "Divisi.n Ventas"
        InfoTrimestral("2.", "Divisi.n Ventas")   // M.todo preferible

     .  Este ejemplo ejecuta un procedimiento con el primer argumento
        pasado por valor y el segundo pasado por referencia:

        nNúmero := 12
        DO InfoAnual WITH nNúmero + 12, nNúmero
        InfoAnual(nNúmero + 12, @nNúmero)         // M.todo preferible

     .  Aqu., se llama a un procedimiento con argumentos saltados
        incluidos en la lista de argumentos:

        DO MostrarPantalla WITH ,,,,"Mi Ventana"
        MostrarPantalla(,,,,"Mi Ventana")         // M.todo preferible

DO CASE
 Ejecuta un bloque de sentencias dependiendo de una condición
------------------------------------------------------------------------------
 Sintaxis

     DO CASE
     CASE <lCondici.n1>
        <sentencias>...
     [CASE <lCondici.n2>]
        <sentencias>...
     [OTHERWISE]
        <sentencias>...
     END[CASE]

 Argumentos

     CASE <lCondici.n> define el bloque de sentencias que se van a
     ejecutar si <lCondici.n> resulta verdadera (.T.).

     OTHERWISE define un bloque de sentencias que se van a ejecutar si
     ningúna de las condiciónes CASE especificadas resulta verdadera (.T.).

 Descripción

     DO CASE...ENDCASE es una estructura de control que ejecuta uno de varios
     posibles bloques de sentencias, dependiendo del resultado de evaluar las
     condiciónes asociadas. Bifurca la ejecución a las sentencias situadas
     después de la primera condición, que resulte verdadera. La ejecución
     prosigue hasta que se encuentra el siguiente CASE, OTHERWISE o ENDCASE.
     El control pasa entonces a la primera sentencia que siga a la pr.xima
     sentencia ENDCASE.

     Si ningúna de las condiciónes CASE resulta verdadera, las sentencias que
     siguen a la sentencia OTHERWISE se ejecutan hasta la sentencia ENDCASE
     correspondiente. Si se omite una sentencia OTHERWISE, el control pasa a
     la primera sentencia que sigue a la sentencia ENDCASE correspondiente.

     Es posible anidar cualquier número de sentencias dentro de una sentencia
     DO CASE, incluyendo otras estructuras de control (es decir, DO WHILE y
     FOR). En una estructura DO CASE sencilla no existe un l.mite fijo en el
     número de sentencias CASE que puede contener.

     DO CASE...ENDCASE es id.ntica a IF...ELSEIF...ENDIF sin que ningúna de
     estas sintaxis tenga alguna ventaja espec.fica sobre la otra.

 Ejemplos

     .  Este ejemplo utiliza DO CASE en una estructura de men.s para
        bifurcar el control seg.n la selecci.n del usuario:

        @ 3, 25 PROMPT "Primera opción"
        @ 4, 25 PROMPT "Segunda opción"
        MENU TO nOpcion
        //
        DO CASE
        CASE nOpcion = 0
           RETURN
        CASE nOpcion = 1
           OpcionUno()
        CASE nOpcion = 2
           OpcionDos()
        ENDCASE

DO WHILE
 Ejecuta un bucle si una condición resulta verdadera
------------------------------------------------------------------------------
 Sintaxis

     [DO] WHILE <lCondici.n>
        <sentencias>...
        [EXIT]
        <sentencias>...
        [LOOP]
        <sentencias>...
     END[DO]

 Argumentos

     <lCondici.n> es la expresión de control l.gica del bucle DO WHILE.

     EXIT bifurca incondiciónalmente el control de una estructura DO
     WHILE o FOR...NEXT a la sentencia inmediatamente después de la pr.xima
     ENDDO o NEXT.

     LOOP bifurca el control a la sentencia DO WHILE o FOR ejecutada m.s
     recientemente.

 Descripción

     DO WHILE...ENDDO es una estructura de control de secuencia que ejecuta
     repetitivamente un bloque de sentencias mientras <lCondici.n> sea
     verdadera. Mientras esta condición resulte verdadera, el control pasa a
     la estructura y continúa.hasta encontrar una sentencia EXIT, LOOP o
     ENDDO. ENDDO devuelve el control a la sentencia DO WHILE y el proceso se
     repite. Si se encuentra una sentencia EXIT, el control se bifurca a la
     sentencia ENDDO o NEXT m.s pr.xima. Si se encuentra una sentencia LOOP,
     el control se bifurca a la sentencia DO WHILE o FOR m.s pr.xima. Cuando
     la condición es falsa, finaliza la estructura DO WHILE y el control pasa
     a la sentencia inmediatamente siguiente a ENDDO.

     EXIT permite terminar una estructura DO WHILE con una condición distinta
     a la condición DO WHILE original. LOOP, sin embargo, no permite ejecutar
     sentencias dentro de DO WHILE basadas en una condición intermedia y
     devuelve el control a la sentencia DO WHILE m.s reciente.

     La estructura DO WHILE puede anidarse dentro de otras estructuras de
     control a cualquier profundidad. El .nico requisito es que cada
     estructura de control se anide adecuadamente.

 Ejemplos

     .  Este ejemplo muestra una estructura de control t.pica de un
        informe sencillo agrupado:

        LOCAL cVendedorAnterior, nTotalCantidad
        USE Ventas INDEX Vendedor NEW
        DO WHILE .NOT. EOF()
           cVendedorAnterior := Ventas->Vendedor
           nTotalCantidad := 0
           DO WHILE cVendedorAnterior = Ventas->Vendedor ;
              .AND. (.NOT. EOF())
              ? Ventas->Vendedor, Ventas->Cantidad
              nTotalCantidad := nTotalCantidad + Ventas->Cantidad
              SKIP
           ENDDO
           ? "Total: ", nTotalCantidad, "del", cVendedorAnterior
        ENDDO
        CLOSE Ventas

     .  Este fragmento de código muestra c.mo puede utilizarse LOOP
        para establecer un tratamiento condiciónal:

        DO WHILE <lCondici.n>
           <tratamiento inicial>...
           IF <Condici.n intermedia>
              LOOP
           ENDIF
           <tratamiento restánte>...
        ENDDO

     .  Este ejemplo muestra la utilización de DO WHILE para emular
        una repetición en una estructura de bucle:

        LOCAL lMas := .T.
        DO WHILE lMas
           <sentencias>...
           lMas := (<lCondici.n>)
        ENDDO

     .  Este ejemplo utiliza un bucle DO WHILE para desplazarse
        secuencialmente por un fichero de base de datos:

        DO WHILE .NOT. EOF()
           <sentencias>...
           SKIP
        ENDDO


EXIT PROCEDURE
 Declara un procedimiento de clausura
------------------------------------------------------------------------------
 Sintaxis

     EXIT PROCEDURE <idProcedimiento>
        [FIELD <lista idCampo> [IN <idAlias>]]
        [LOCAL <identificador> [[:= <inicializador>]]]
        [MEMVAR <lista identificador>]
        .
        . <sentencias ejecutables>
        .
        [RETURN]

 Argumentos

     EXIT PROCEDURE declara un procedimiento que se ejecuta en la
     terminaci.n del programa.

     <idProcedimiento> es el nombre del procedimiento de clausura que se
     va a declarar. Los nombres de procedimientos de clausura pueden tener
     cualquier longitud, pero sólo son significativosólos primeros 10
     carácteres. Los nombres no deben comenzar con un signo de subrayado,
     pero pueden contener cualquier combinación de carácteres, números o
     signos de subrayado.

     FIELD declara una lista de identificadores para utilizar como
     nombres de campo siempre que se encuentren. Si se especifica la cláusula
     IN, la referencia al nombre declarado incluye una referencia impl.cita
     al alias especificado.

     LOCAL declara y, opciónalmente, inicializa una lista de variables o
     matrices, cuya visibilidad y vida es la del procedimiento actual.

     MEMVAR declara una lista de identificadores para utilizar como
     variables o matrices de memoria privadas o públicas, siempre que se
     encuentren.

     RETURN pasa el control al siguiente procedimiento de clausura o al
     sistema operativo, si no hay pendiente ningún otro procedimiento de
     clausura.

 Descripción

     La sentencia EXIT PROCEDURE declara un procedimiento que se ejecutar.
     cuando finalice el programa. Los procedimientos de clausura se llaman
     después de que se haya completado la .ltima sentencia ejecutable en una
     aplicación de CA-Clipper. Las sentencias EXIT PROCEDURE pueden
     utilizarse para ejecutar tareas de mantenimiento habituales, como por
     ejemplo, guardar los parámetros de configuración en un fichero, cerrar
     un fichero de registro o concluir una sesi.n de comunicaciones.

     La visibilidad de los procedimientos de clausura est. limitada al
     sistema; por lo tanto, no es posible llamar a un procedimiento de
     clausura desde un procedimiento o función definido por el usuario. Los
     procedimientos de clausura no reciben parámetros.

     Una vez que se ha completado la .ltima sentencia ejecutable, el control
     pasa de un procedimiento de clausura al siguiente hasta que se ha
     llamado a todos los procedimientos de la lista de clausura. El control
     pasa seguidamente al sistema operativo.

     La sentencia ANNOUNCE declara un identificador de módulo para un módulo
     fuente (.prg). Una vez declarado, se hace referencia a las sentencias
     EXIT PROCEDURE con este identificador de módulo. Una aplicación puede
     utilizar cualquier número de procedimientos de clausura, solicitando de
     forma expl.cita mediante REQUEST sus identificadores de módulo.

     Los procedimientos de clausura solicitados para una aplicación se
     mencionan, de forma colectiva, como la lista de clausura. No existe un
     orden de ejecución obligatorio de procedimientos en la lista de
     clausura; sin embargo, si un procedimiento de clausura se declara en el
     mismo módulo fuente (.prg) que la rutina principal o ra.z, .ste ser. el
     primer procedimiento de clausura llamado.

     La terminaci.n de una aplicación de CA-Clipper dada puede atribuirse a
     alguna de las siguientes causas:

     .  RETURN desde la rutina principal o ra.z

     .  el mandato QUIT

     .  la ejecución de un BREAK sin incluir BEGIN SEQUENCE...END

     .  error irrecuperable

     No se puede garantizar la ejecución de un procedimiento de clausura
     cuando el sistema detecta un error irrecuperable. Si se ha producido un
     error durante un procedimiento de clausura, el sistema vuelve al DOS.
     Los procedimientos de clausura pendientes no se llaman.

 Ejemplos

     .  En este ejemplo se ilustra la construcci.n de un mecanismo de
        temporizaci.n simple, utilizando INIT y EXIT PROCEDURE:

        // imprime la cantidad de tiempo necesario para,
        // leer, ordenar y mostrar una lista de nombres
        // de ficheros.

        ANNOUNCE MiSistema

        STATIC nInicio

        PROCEDURE Main()
           AEVAL( ASORT( DIRECTORY( "*.*" ) ),;
               { | aInfoFichero | QOUT( aInfoFichero[ 1 ] ) } )

           RETURN

        INIT PROCEDURE MiInicio()
           nInicio := SECONDS()
           RETURN

        EXIT PROCEDURE MiClausura()
           ?
           ? "Tiempo transcurrido: "
           ?? SECONDS() - nInicio
           RETURN

EXTERNAL*
 Declara al enlazador una lista de nombres de procedimientos o funciónes
 definidas por el usuario para que se incluyan en el ejecutable
------------------------------------------------------------------------------
 Sintaxis

     EXTERNAL <lista idProcedimientos>

 Argumentos

     <lista idProcedimientos> es la lista de procedimientos, funciónes
     definidas por el usuario o procedimientos de formato que deben a.adirse
     a la lista de rutinas que se enlazar.n en el fichero ejecutable actual
     (.EXE).

 Descripción

     EXTERNAL es una sentencia de declaración que especifica referencias sin
     codificar para el enlazador. Al igual que con el resto de sentencias de
     declaración, una sentencia EXTERNAL debe especificarse antes de
     cualquier sentencia ejecutable en cualquier fichero de programa o en una
     definición de procedimiento o función definida por el usuario.

     Durante la compilación del código fuente de CA-Clipper, todas las
     referencias expl.citas a los procedimientos y funciónes definidas por el
     usuario se pasan al enlazador. En algunos casos, no existen referencias
     a los nombres de procedimientos o de funciónes definidas por el usuario
     hasta el tiempo de ejecución. EXTERNAL resuelve esta situaci.n forzando
     a los procedimientos nombrados o funciónes definidas por el usuario a
     ser enlazados aunque no se haga referencia expl.cita a ellos en ningún
     módulo fuente. Esto es importante en diversos casos:

     .  Procedimientos, funciónes definidas por el usuario o formatos
        a los que se hace referencia mediante macroexprexiones o variables
        que las contengan

     .  Procedimientos y funciónes definidas por el usuario utilizadas
        en REPORT y LABEL FORMs y no referidos en el código fuente

     .  funciónes definidas por el usuario en las claves de índice y
        no referidas en el código fuente

     .  funciónes de usuario ACHOICE(), DBEDIT() o MEMOEDIT()

     Para agrupar declaraciónes EXTERNAL comunes, sit.elas en un fichero de
     cabecera y después incluya mediante #include el fichero de cabecera en
     cada módulo de programa (.prg) que pueda utilizarlas de forma indirecta.

     EXTERNAL es una sentencia de compatibilidad y por lo tanto, no es
     recomendable. Ha sido sustituida por la sentencia REQUEST que define una
     lista de identificadores de módulo para el enlazador.

 Ejemplos

     .  Estos ejemplos son ficheros de cabecera equivalentes que
        constan de referencias EXTERNAL comunes para REPORT FORMs:

        // Externals.ch
        EXTERNAL HARDCR
        EXTERNAL TONE
        EXTERNAL MEMOTRAN
        EXTERNAL STRTRAN

        // Externals.ch
        EXTERNAL HARDCR, TONE, MEMOTRAN, STRTRAN

FIELD
 Declara nombres de campo de base de datos
------------------------------------------------------------------------------
 Sintaxis

     FIELD <lista idCampos> [IN <idAlias>]

 Argumentos

     <lista idCampos> es una lista de nombres para declarar como campos
     para el compilador.

     IN <idAlias> especifica un alias que debe asumirse cuando existen
     referencias sin alias a los nombres especificados en la <lista
     idCampos>. Las referencias sin alias a las variables en <lista idCampos>
     se tratan como si estuvieran precedidas por el alias de campo especial
     (FIELD->).

 Descripción

     La sentencia FIELD declara los nombres de campos de base de datos para
     el compilador y, opciónalmente, proporciona un alias impl.cito para cada
     nombre. Esto permite al compilador resolver referencias a variables sin
     alias explícito--asumiendo impl.citamente el <idAlias> especificado.
     S.lo se ven afectadas las referencias expl.citas sin alias a los campos
     especificados en <lista idCampos>. La sentencia FIELD, al igual que
     todas las declaraciónes, no tiene efecto sobre las referencias
     efectuadas dentro de macroexpresiónes o variables que las contengan.

     La sentencia FIELD no abre un fichero de base de datos ni verifica la
     existencia de campos especificados. Esto es útil, especialmente, para
     garantizar las referencias correctas a los campos cuya accesibilidad se
     conoce en el tiempo de ejecución. Si se intenta acceder a campos cuando
     la base de datos asociada no est. en uso, se produce un error.

     El ámbito de la declaración FIELD es el procedimiento o función en la
     que se produce o todo el módulo fuente (.prg) si la declaración precede
     todas las declaraciónes PROCEDURE o FUNCTION y se especifica la opción
     de compilador /N.

     Las sentencias FIELD, al igual que otras declaraciónes, deben preceder a
     cualquier sentencia ejecutable en la definición de procedimiento o
     función, o en el módulo fuente (.prg) si la declaración tiene un ámbito
     de módulo.

     FIELD utilizado con la opción de compilador /W ejecuta una comprobaci.n
     de variables no declaradas durante la compilación.

     Si desea obtener más información sobre declaraciónes y ámbitos de
     variables, consulte el apartado Variables del capítulo Conceptos Básicos
     de la gu.a Programaci.n y Utilidades.

 Ejemplos

     .  Esta función definida por el usuario incluye sentencias para
        declarar nombres de campos de bases de datos tanto en el .rea de
        trabajo actual como en el .rea Empleado:

        FUNCTION MuestraRegistro
           FIELD NoClie, NoPedido, Vendedor
           FIELD NomEmp, CodEmp IN Empleado
           USE Empleado NEW
           USE Pedidos NEW
           //
           ? NoClie               // Refiere a Pedidos->NoClie
           ? NomEmp               // Refiere a Empleado->NomEmp
           //
           CLOSE Pedidos
           CLOSE Empleado
           RETURN NIL


FOR
 Ejecuta un bloque de sentencias un número determinado de veces
------------------------------------------------------------------------------
 Sintaxis

     FOR <idContador> := <nInicio> TO <nFin>
        [STEP <nIncremento>]
        <sentencias>...
        [EXIT]
        <sentencias>...
        [LOOP]
     NEXT

 Argumentos

     <idContador> es el nombre de la variable de control o contador del
     bucle. Si el <idContador> especificado no es visible o no existe, se
     crea una variable privada.

     <nInicio> es el valor inicial asignado a <idContador>. Si
     <nIncremento> es negativo, <nInicio> debe ser mayor que <nFin>.

     TO <nFin> define el valor final de <idContador>. Si <nIncremento> es
     negativo, <nInicio> debe ser superior a <nFin>; en caso contrario,
     <nInicio> debe ser menor que <nFin>.

     STEP <nIncremento> define la cantidad en que var.a <idContador> para
     cada iteraci.n del bucle. <nIncremento> puede ser positivo o negativo.
     Si no se especifica la cláusula STEP, <idContador> se incrementa en uno
     en cada iteraci.n del bucle.

     EXIT bifurca el control incondiciónalmente a la sentencia
     inmediatamente siguiente a la sentencia NEXT m.s pr.xima.

     LOOP bifurca el control a la sentencia FOR o DO WHILE ejecutada m.s
     recientemente.

 Descripción

     FOR...NEXT es una estructura de control que ejecuta un bloque de
     sentencias un número de veces especificado. La estructura de control
     efect.a un bucle desde el valor inicial de <idContador> hasta el l.mite
     especificado por <nFin>, desplaz.ndose a trav.s del rango de valores de
     la variable de control con un incremento especificado mediante
     <nIncremento>. Todas las expresiónes de la sentencia FOR se reeval.an en
     cada iteraci.n del bucle. Por lo tanto, las expresiónes <nInicio> y
     <nFin> pueden cambiarse a medida que act.a la estructura de control.

     Un bucle FOR funcióna hasta que <idContador> es mayor que <nFin> o se
     encuentra una sentencia EXIT. El control bifurca entonces a la sentencia
     siguiente a la sentencia NEXT correspondiente. Si se encuentra una
     sentencia LOOP, el control bifurca de nuevo a la sentencia FOR actual.

     Si <nIncremento> es un valor negativo, <idContador> se reduce en lugar
     de incrementarse. Sin embargo, el bucle FOR continúa.hasta que
     <idContador> es menor que <nFin>. Esto significa que <nFin> debe ser
     menor que <nInicio> cuando comienza el bucle FOR.

     Los bucles FOR son .tiles para recorrer matrices donde se utiliza
     <idContador> como subíndice de matriz. Consulte el ejemplo que se
     muestra m.s adelante.

     Las construcciones FOR...NEXT pueden anidarse dentro de otras
     estructuras de control a cualquier profundidad. El .nico requisito es
     que cada estructura de control se anide de forma adecuada.

 Ejemplos

     .  Este ejemplo recorre una matriz en orden ascendente:

        nLongMatriz := LEN(aMatriz)
        FOR i := 1 TO nLongMatriz
           <sentencias>...
        NEXT

     .  Para recorrer una matriz en orden descendente:

        nLongMatriz := LEN(aMatriz)
        FOR i := nLongMatriz TO 1 STEP -1
           <sentencias>...
        NEXT

FUNCTION
 Declara el nombre y parámetros formales de una función definida por el
 usuario
------------------------------------------------------------------------------
 Sintaxis

     [STATIC] FUNCTION <idfunción>
        [(<idLista Par.metros>)]
        [LOCAL <identificador> [[:= <inicializador>], ... ]]
        [STATIC <identificador> [[:= <inicializador>], ... ]]
        [FIELD <lista identificadores> [IN <idAlias>]]
        [MEMVAR <lista identificadores>]
        .
        . <sentencias ejecutables>
        .
        RETURN <exp>

 Argumentos

     <idfunción> es el nombre de la función definida por el usuario que
     debe declararse. Los nombres de función definidos por el usuario pueden
     tener cualquier longitud, pero sólo son significativosólos primeros 10
     carácteres. Los nombres pueden contener cualquier combinación de
     carácteres, números o signos de subrayado, pero deben comenzar con un
     carácter o signo de subrayado. Los subrayados iniciales no son
     recomendables puesto que están reservados para funciónes internas.

     <idLista Par.metros> es la declaración de una o más variables de
     parámetro. Las variables especificadas en esta lista se han declarado
     como locales.

     STATIC FUNCTION declara una función definida por el usuario que sólo
     puede llamarse desde procedimientos y funciónes definidas por el
     usuario, declaradas en el mismo módulo fuente (.prg).

     LOCAL declara y, opciónalmente, inicializa una lista de variables o
     matrices cuya visibilidad y tiempo de vida es la función actual.

     STATIC declara y, opciónalmente, inicializa una lista de variables o
     matrices, cuya visibilidad es la función actual definida por el usuario
     y cuyo tiempo de vida es la duraci.n del programa.

     FIELD declara una lista de identificadores para utilizar como
     nombres de campo siempre que se encuentren. Si se especifica la cláusula
     IN, las referencias al nombre declarado incluyen una referencia
     impl.cita al alias especificado.

     MEMVAR declara una lista de identificadores para utilizar como
     variables de memoria privadas o públicas o matrices siempre que se
     encuentren.

     <identificador> y <lista identificadores> son etiquetas que
     deben utilizarse como nombres de variables o matrices.

     <inicializador> es un valor que se asigna originalmente a una matriz
     o variable en una expresión de inicializaci.n en línea.

     RETURN <exp> pasa el control de nuevo al procedimiento o función
     definida por el usuario que la ha llamado, devolviendo el resultado de
     <exp> como valor de retorno de la función. Cada función debe tener, como
     mínimo, una sentencia RETURN que devuelva un valor. Las sentencias
     RETURN pueden colocarse en cualquier parte del cuerpo de una función.

 Descripción

     La sentencia FUNCTION declara una función definida por el usuario y una
     lista opciónal de variablesólocales para recibir parámetros, que con
     frecuencia se denominan parámetros formales. Una función definida por el
     usuario es un subprograma compuesto por un conjunto de declaraciónes y
     sentencias, que se ejecutan siempre que se hace referencia a <idfunción>
     seguido por un par de paréntesis de apertura y cierre. Una definición de
     función comienza con una sentencia FUNCTION y finaliza con la siguiente
     sentencia FUNCTION o PROCEDURE o el final del fichero.

     Las funciónes encapsulan un bloque de código de c.lculo y después, crean
     expresiónes útilizando el valor devuelto. Las funciónes y procedimientos
     aumentan tanto la legibilidad como la modularidad, aislan los cambios y
     ayudan a manejar situaciones complejas.

     Una función de CA-Clipper es igual que un procedimiento, con la
     excepci.n de que debe devolver un valor. El valor devuelto puede ser
     cualquier tipo de datos incluyendo una matriz, un bloque de código o
     NIL. Cada función debe comenzar con una sentencia FUNCTION y contener,
     por lo menos, una sentencia RETURN con un argumento. Las declaraciónes
     de funciónes no pueden anidarse dentro de otras definiciónes de función.
     Una función definida por el usuario puede utilizarse dondequiera que se
     admitan funciónes estándar, incluyendo expresiónes.

     La visibilidad de los nombres de función se divide en dos clases. Las
     funciónes que son visibles en cualquier lugar de un programa se
     denominan funciónes públicas y se declaran con una sentencia FUNCTION.
     Las funciónes que son visibles sólo dentro del módulo fuente actual
     (.prg) se denominan funciónes estáticas y se declaran con una sentencia
     STATIC FUNCTION. Las funciónes estáticas tienen ámbito de módulo.

     Las funciónes estáticas limitan la visibilidad de un nombre de función,
     restringiendo por tanto el acceso a las mismas. Por este motivo, los
     subsistemas definidos dentro de un módulo fuente simple (.prg) pueden
     proporcionar un protocolo de acceso con una serie de funciónes públicas
     y ocultar los detalles de implantaci.n del subsistema dentro de
     funciónes y procedimientos estáticos. Puesto que las referencias de
     función estáticas se resuelven en el tiempo de compilación, .stas se
     apropian de las referencias a las funciónes públicas, que se resuelven
     en el tiempo de enlace. Esto garantiza que, dentro de un módulo fuente,
     una referencia a una función estática ejecutar. esa función si existe un
     conflicto de nombre con una función pública.

     Para más información sobre funciónes definidas por el usuario,
     declaraciónes de variables y paso de parámetros, consulte el capítulo
     Conceptos Básicos en la gu.a Programaci.n y Utilidades.

 Notas

     .  Llamada a una función definida por el usuario: Utilice la
        misma notaci.n para llamar a una función definida por el usuario que
        cuando efect.a una llamada a una función de CA-Clipper estándar:

        <idfunción>([<lista argumentos>])

        Puede llamar a una función definida por el usuario dentro de una
        expresión o en una línea, por s. misma. En el segundo caso, el valor
        de retorno se ignora.

        También puede llamar a una función definida por el usuario como una
        expresión de alias, precedi.ndola con un alias e incluy.ndola entre
        paréntesis:

        <idAlias>->(<idfunción>(<lista argumentos>))

        Cuando se llama a una función definida por el usuario como una
        expresión de alias, se selecciona el área de trabajo asociada con
        <idAlias>, la expresión se ejecuta y el área de trabajo original se
        selecciona de nuevo. Puede especificar una expresión de alias en una
        línea, por s. misma, del mismo modo que har.a con cualquier otra
        expresión.

        Una función definida por el usuario en CA-Clipper puede llamarse a s.
        misma, repetidamente. Esto significa que puede efectuar una
        referencia a una función definida por el usuario en sentencias o
        expresiónes iguales a la definición de función efectuada por el
        usuario.

     .  Par.metros: Tanto las funciónes definidas por el usuario,
        como los procedimientos, pueden recibir parámetros pasados por el
        procedimiento o función que los invoca, o desde la línea de mandatos
        del DOS. Un parámetro es un espacio reservado para un valor o una
        referencia. En CA-Clipper, existen dos formas de expresar parámetros:
        puede declarar una lista de nombres de variablesólocales como parte
        de la declaración FUNCTION (referida como parámetros formales) o
        puede especificar una lista de variables privadas en una sentencia
        PARAMETERS independiente. Observe que no puede mezclar una
        declaración de parámetros formales con una sentencia PARAMETERS. Si
        intenta hacerlo de ese modo, se genera un error de compilación.

        Las funciónes reciben parámetros en el orden que se les han pasado.
        En CA-Clipper, el número de parámetros no tiene por qu. coincidir con
        el número de argumentos pasados. Puede saltarse argumentos u
        omitirlos de la lista de argumentos. Un parámetro que no recibe un
        valor o la referencia se inicializa con NIL. Puede saltarse un
        parámetro pasando NIL. Si se especifican argumentos, PCOUNT()
        devuelve la posición del último argumento pasado.

        Los parámetros especificados en una función definida por el usuario
        pueden recibir argumentos pasados por valor o referencia. El m.todo
        por defecto para expresiónes y variables es por valor. Esto incluye
        variables que contienen referencias a matrices y objetos. Todas las
        variables excepto las de campo, cuando están precedidas por el
        operador pasar por referencia (@), se pasan por referencia. Las
        variables de campo no pueden pasarse por referencia y se pasan
        siempre por valor.

 Ejemplos

     .  Este ejemplo muestra una función definida por el usuario que
        da formato a valores numéricos como moneda:

        ? Moneda( 1000 )               // Resultado: $1,000.00

        FUNCTION Moneda( nNúmero )
           LOCAL cnúmero
           IF nNúmero < 0
              cnúmero := TRANSFORM(-1 * nNúmero, ;
                    "999,999,999,999.99")
              cnúmero := PADL("($" + LTRIM(cnúmero) + ")", ;
                    LEN(cnúmero))
           ELSE
              cnúmero := TRANSFORM(nNúmero, ;
                    "999,999,999,999.99")
              cnúmero := PADL("$" + LTRIM(cnúmero), ;
                    LEN(cnúmero))
           ENDIF
           RETURN cnúmero

     .  En este ejemplo se muestra una función definida por el usuario
        que toma una cadena de carácteres con formato como una lista separada
        por comas y devuelve una matriz con un elemento por objeto:

        aLista := ListaComoMatriz("Uno, Dos")
        // Resultado: {"Uno", "Dos"}

        FUNCTION ListaComoMatriz( cLista )
           LOCAL nPos
           // Definir una matriz vac.a
           LOCAL aLista := {}
           //
           DO WHILE (nPos := AT(",", cLista)) != 0
              // A.adir un nuevo elemento
              AADD(aLista, SUBSTR(cLista, 1, nPos - 1))
              cLista := SUBSTR(cLista, nPos + 1)
           ENDDO
           AADD(aLista, cLista)
           //
           // Devolver la matriz
           RETURN aLista

     .  En este ejemplo se comprueba si se ha saltado alg.n argumento,
        comparando el parámetro con NIL:

        FUNCTION MiFunc( param1, param2, param3 )
           IF param2 == NIL
              param2 := "valor por defecto"
           ENDIF
           .
           . <sentencias>
           .
           RETURN NIL

     .  En este ejemplo se utiliza la función definida por el usuario,
        Moneda() (definida anteriormente), como una expresión con alias:

        USE Facturas NEW
        USE Cliente NEW
        ? Facturas->(Moneda(Cantidad))

IF
 Ejecuta uno o m.s bloques alternativos de sentencias
------------------------------------------------------------------------------
 Sintaxis

     IF <lCondici.n1>
        <sentencias>...
     [ELSEIF <lCondici.n2>]
        <sentencias>...
     [ELSE]
        <sentencias>...
     END[IF]

 Argumentos

     <lCondici.n> es una expresión l.gica de control. Si resulta
     verdadera (.T.), todas las sentencias siguientes se ejecutan hasta que
     se encuentra una sentencia ELSEIF, ELSE o ENDIF.

     ELSEIF <lCondici.n> identifica las sentencias que se van a ejecutar
     si la condición asociada resulta verdadera (.T.) y todas las condiciónes
     IF o ELSEIF anteriores son falsas (.F.). Puede especificarse cualquier
     número de sentencias ELSEIF en la misma estructura de control
     IF...ENDIF.

     ELSE identifica las sentencias que se deben ejecutar si la condición
     IF y todas las condiciónes ELSEIF anteriores son falsas (.F.).

 Descripción

     La estructura de control IF act.a bifurcando la ejecución a las
     sentencias situadas después de la primera condición que resulte
     verdadera (.T.), en la sentencia IF o en alguna de las ELSEIF. La
     ejecución continúa.hasta que se encuentre la siguiente sentencia ELSEIF,
     ELSE o ENDIF, donde la ejecución salta a la primera sentencia situada
     después del ENDIF.

     Si ningúna condición resulta verdadera (.T.) el control pasa a la
     primera sentencia situada después de la sentencia ELSE. Si no se
     especifica ningúna sentencia ELSE, el control pasa a la primera
     sentencia situada después de la sentencia ENDIF.

     Las estructuras IF...ENDIF pueden anidarse dentro de otras estructura
     IF...ENDIF y otras estructuras de control. Estas estructuras, no
     obstante, deben estar correctamente anidadas.

     La forma IF...ELSEIF...ENDIF de la estructura IF es id.ntica a la
     estructura DO CASE...ENDCASE. No existe ningúna ventaja espec.fica de
     una sintaxis sobre la otra. La estructura IF es también similar a la
     función IF() que puede utilizarse dentro de expresiónes.

 Ejemplos

     .  Este ejemplo eval.a un número de condiciónes útilizando una
        estructura IFELSEIF...ENDIF :

        LOCAL nNúmero := 0
        //
        IF nNúmero < 50
           ? "Menor que 50"
        ELSEIF nNúmero = 50
           ? "Igual a 50"
        ELSE
           ? "Mayor que 50"
        ENDIF


INIT PROCEDURE
 Declara un procedimiento de inicializaci.n
------------------------------------------------------------------------------
 Sintaxis

     INIT PROCEDURE <idProcedimiento> [(<lista idPar.m>)]
        [FIELD <lista idCampos> [IN <idAlias>]]
        [LOCAL <identificador> [[:= <inicializador>]]]
        [MEMVAR <Lista Identificadores>]
        .
        . <sentencias ejecutables>
        .
        [RETURN]

 Argumentos

     INIT PROCEDURE declara un procedimiento que se ejecutar. cada vez
     que se inicie el programa.

     <idProcedimiento> es el nombre del procedimiento de inicializaci.n
     que se va a declarar. Los nombres de procedimiento de inicializaci.n
     pueden tener cualquier longitud pero sólo los 10 primeros carácteres son
     significativos. Los nombres no pueden comenzar con el carácter de
     subrayado, pero pueden contener cualquier combinación de carácteres,
     números o subrayados.

     <lista idPar.m> es la declaración de una o más variables de
     parámetros. Las variables especificadas en esta lista se declaran como
     variablesólocales.

     FIELD declara una lista de identificadores que se utilizan como
     nombres de campos cuando se encuentran. Si se especifica la cláusula IN,
     la referencia al nombre declarado incluye cualquier referencia impl.cita
     al alias especificado.

     LOCAL declara y, opciónalmente, inicializa una lista de variables o
     matrices cuya visibilidad y tiempo de vida se limitan al procedimiento
     actual.

     MEMVAR declara una lista de identificadores que se utilizar.n como
     matrices o variables de memoria públicas o privadas cuando se
     encuentran.

     RETURN pasa el control al siguiente procedimiento de inicializaci.n
     o a la primera rutina ejecutable del programa si no hay otros
     procedimientos de inicializaci.n pendientes.

 Descripción

     La sentencia INIT PROCEDURE declara un procedimiento que se ejecuta cada
     vez que se inicia el programa. Los procedimientos de inicializaci.n se
     invocan antes de la primera sentencia ejecutable de una aplicación CA-
     Clipper y son .tiles para realizar tareas de inicializaci.n frecuentes,
     como lectura de configuraciónes o apertura de un puerto de
     comunicaciones.

     Los procedimientos de inicializaci.n son ejecutados impl.citamente por
     CA-Clipper al inicio del programa. La visibilidad de estos procesos se
     limita al sistema, por lo que no es posible invocar un procedimiento de
     inicializaci.n desde un procedimiento o función definida por el usuario.
     Cada procedimiento de inicializaci.n recibe una copia de los argumentos
     de la línea de mandatos del DOS utilizada para invocar la aplicación.

     El control pasa de un procedimiento de inicializaci.n al siguiente,
     hasta que se hayan ejecutado todos los procedimientos de inicializaci.n.
     El control pasa entonces a la primera sentencia ejecutable del programa.

     La sentencia ANNOUNCE declara un identificador de módulo para un módulo
     fuente (.prg). Una vez declarados, se hace referencia a los
     procedimientos de inicializaci.n mediante este identificador de módulo.
     Una aplicación puede utilizar cualquier número de procedimientos de
     inicializaci.n solicitando con REQUEST sus identificadores de módulo.

     Los procedimientos de inicializaci.n solicitados por una aplicación se
     denominan colectivamente como lista de inicializaci.n. Aunque no hay un
     orden de ejecución por defecto en los procedimientos de la lista de
     inicializaci.n, se aplican las siguientes reglas:

     .  El procedimiento de inicializaci.n de CA-Clipper, CLIPINIT, se
        invoca siempre el primero.

     .  Si se declara un procedimiento de inicializaci.n en el mismo
        módulo fuente (.prg) que la rutina principal de la aplicación, ser.
        el último procedimiento de inicializaci.n invocado.

     CLIPINIT es invocado el primero para asegurar la integridad del sistema
     instalando el sistema de recuperaci.n de errores por defecto (ErrorSys).
     Cuando termina CLIPINIT, el control pasa al primer procedimiento de la
     lista de inicializaci.n.

     Si se produce un error durante el arranque del sistema, el sistema
     vuelve al DOS sin invocar los restántes procedimientos de
     inicializaci.n.

 Ejemplos

     .  Este ejemplo utiliza INIT y EXIT PROCEDURE para guardar y
        restablecer el contenido del sistema operativo. Solicitando con
        REQUEST "GuardarDos" en su módulo fuente principal, se preserva el
        contenido del sistema operativo:

        ANNOUNCE GuardarDos

        #define DOS_SCREEN      1
        #define DOS_ROW         2
        #define DOS_COL         3
        #define DOS_CURSOR      4
        #define DOS_COUNT       4

        STATIC saGuardarDos[ SD_COUNT ]

        INIT PROCEDURE GuardarDos()
           SAVE SCREEN TO saGuardarDos[ DOS_SCREEN ]
           saGuardarDos[ DOS_ROW ]  := ROW()
           saGuardarDos[ DOS_COL ]  := COL()
           saGuardarDos[ DOS_CURSOR ] := SETCURSOR()
           RETURN

        EXIT PROCEDURE RestablecerDos()
           RESTORE SCREEN FROM saGuardarDos[ DOS_SCREEN ]
           SETPOS ( saGuardarDos[ DOS_ROW ], saGuardarDos[ DOS_COL ] )
           SETCURSOR( saGuardarDos[ DOS_CURSOR ] )
           RETURN


LOCAL
 Declara e inicializa variables y matricesólocales
------------------------------------------------------------------------------
 Sintaxis

     LOCAL <identificador> [[:= <inicializador>],...]

 Argumentos

     <identificador> es el nombre de una variable o matriz que se declara
     como local. Si el <identificador> va seguido de corchetes ([]), se crea
     una matriz. Si el <identificador> es una matriz, la sintaxis para
     especificar el número de elementos de cada dimensión puede ser
     matriz[<nElementos>, <nElementos2>,...] o
     matriz[<nElementos>][<nElementos2>]... El número máximo de elementos por
     dimensión es 4.096. El número máximo de dimensiónes por matriz sólo est.
     limitado por la memoria disponible.

     <inicializador> es la asignación opciónal de un valor a una nueva
     variable local. Los identificadores de matrices, no obstante, no pueden
     recibir valores con un <inicializador>. Un <inicializador> para una
     variable local est. formado por el operador de asignación en línea (:=)
     seguido por cualquier expresión víaacute;lida de CA-Clipper incluyendo una
     matriz literal. Si no se especifica ningún <inicializador> explícito, se
     asigna a la variable un valor inicial NIL. En caso de una matriz, todos
     los elementos son NIL.

     Nota: El operador de macroexpresiónes (&) no puede utilizarse en una
     declaración LOCAL.

 Descripción

     LOCAL es una sentencia que declara locales una o más variables o
     matrices respecto al procedimiento o función actual definida por el
     usuario y debe especificarse antes que cualquier sentencia ejecutable,
     incluyendo PRIVATE, PUBLIC y PARAMETERS. Las declaraciónes de variables
     locales ocultan todas las variables privadas heredadas o públicas
     visibles que tengan el mismo nombre. No obstante, una sentencia LOCAL
     que declare una variable ya declarada causa un error de compilación y no
     se genera código objeto (.OBJ). Este error puede suceder por existir dos
     declaraciónes de la misma variable en la misma rutina o como resultado
     de declarar una variable con ámbito víaacute;lido en todo el fichero. Las
     sentencias de declaración incluyen FIELD, MEMVAR y STATIC.

     Las variablesólocales son visibles sólo dentro del procedimiento o
     función actual definida por el usuario y, a diferencia de las variables
     privadas, no son visibles en las rutinas invocadas. Las variables
     locales se crean autom.ticamente cada vez que se ejecuta el
     procedimiento en el que están declaradas. Contin.an existiendo y
     mantienen sus valores hasta que el procedimiento o función definido por
     el usuario en el que están declaradas devuelve el control al código que
     lo invoc.. Si un procedimiento o función definido por el usuario se
     invoca recursivamente (se llama a s. mismo), cada activaci.n crea un
     nuevo conjunto de variablesólocales.

     El valor inicial de las variablesólocales y elementos de matriz es NIL
     si no se inicializan explícitamente en la lista del inicializador o con
     una asignación. La expresión del inicializador puede ser cualquier
     expresión víaacute;lida de CA-Clipper, incluyendo llamadas a función. Recuerde
     que las declaraciónes de matrices no pueden tener un inicializador.

     El número máximo de variablesólocales en un programa sólo está limitado
     por la memoria disponible. No obstante, las matrices asignadas a una
     variable local tienen un l.mite de 4.096 elementos por dimensión.

     Si desea más información sobre las declaraciónes y ámbitos de variables,
     consulte el apartado Variables en el capítulo Conceptos Básicos de la
     gu.a Programaci.n y Utilidades.

 Notas

     .  Inspección de variablesólocales en el depurador: Para
        acceder a nombres de variablesólocales con el depurador de CA-
        Clipper, debe compilar los ficheros de programa (prg) utilizando la
        opción /B para incluir la información de la variable local en el
        fichero objeto.

     .  Par.metrosólocales: Declare una lista de parámetros
        locales como parte de una declaración FUNCTION o PROCEDURE,
        encerrando la lista entre paréntesis después de <idfunción>:

        FUNCTION <idfunción>(<lista idPar.m>)

        La declaración de parámetrosólocales tiene precedencia sobre la
        creaci.n de parámetros privados con la sentencia PARAMETERS.

     .  Macroexpresiónes: No se puede hacer referencia a variables
        locales en macroexpresiónes o variables que las contengan. Si hace
        referencia a una variable local dentro de una variable que contiene
        una macroexpresión, se hace referencia en su lugar a alguna variable
        pública o privada que tenga el mismo nombre. Si no existe tal
        variable, se produce un error de ejecución.

     .  Ficheros de memoria: Las variablesólocales no pueden
        guardarse o restablecerse (SAVE o RESTORE) desde ficheros de memoria
        (.mem).

     .  Tipo de una variable local: Dado que TYPE() utiliza el
        operador de macroexpresiónes (&) para evaluar su argumento, no puede
        utilizarse para determinar el tipo de una variable local o estática o
        una expresión que contenga alguna referencia de variable local o
        estática. La función VALTYPE() sirve para averiguar este valor.
        VALTYPE() eval.a el argumento y devuelve su tipo.

 Ejemplos

     .  Este ejemplo declara dos matricesólocales y dos variables
        locales:

        LOCAL aMatr1[20, 10], aMatr2[20][10], var1, var2

     .  Este ejemplo declara dos variablesólocales con
        inicializadores. La primera se inicializa con un valor de fecha y la
        segunda con una matriz literal:

        LOCAL dCuando := DATE()
        LOCAL aVegetales := {"Tomate", "Col", "Jud.a"}


MEMVAR
 Declara nombres de variables privadas y públicas
------------------------------------------------------------------------------
 Sintaxis

     MEMVAR <idLista varmem>

 Argumentos

     <idLista varmem> es la lista de nombres de variables públicas y
     privadas que se van a declarar al compilador.

 Descripción

     MEMVAR es una declaración que hace que el compilador resuelva las
     referencias a variables especificadas sin un alias explícito, asumiendo
     impl.citamente un alias de variable de memoria (MEMVAR->). Esto sólo
     afecta a las referencias expl.citas sin alias de las variables
     especificadas. MEMVAR, como todas las declaraciónes, no afecta a las
     referencias realizadas dentro de macroexpresiónes o variables que las
     contengan.

     La sentencia MEMVAR no crea variables ni comprueba su existencia. Sirve
     para asegurar que sean correctas las referencias a variables que se sabe
     que existir.n durante la ejecución. Durante la ejecución, las variables
     especificadas deben crearse con sentencias PRIVATE, PARAMETERS o PUBLIC.
     Esto puede ocurrir en el procedimiento que contiene la declaración
     MEMVAR o en un procedimiento de nivel superior. Si se intenta acceder a
     las variables antes de que se hayan creado, se produce un error.

     El ámbito de la declaración MEMVAR es el procedimiento o función en el
     que aparece, o todo el fichero fuente si precede a una sentencia
     PROCEDURE o FUNCTION y se utiliza la opción de compilador /N. La opción
     /N suprime la definición autom.tica de un procedimiento que tiene el
     mismo nombre que el módulo fuente (.prg).

     Al igual que las restántes declaraciónes, MEMVAR debe preceder a todas
     las sentencias ejecutables, incluyendo las sentencias PARAMETERS, PUBLIC
     y PRIVATE de una definición de procedimiento o función; o debe situarse
     al principio del módulo fuente (.prg) si el ámbito de la declaración es
     todo el módulo.

     MEMVAR puede utilizarse con la opción de compilador /W, que genera
     mensajes de advertencia para referencias a variables ambiguas, lo que
     permite comprobar la existencia de variables no declaradas durante la
     compilación.

     Si desea más información sobre las declaraciónes de variables y su
     ámbito, consulte el apartado Variables del capítulo Conceptos Básicos de
     la guía de Programación y Utilidades.

 Ejemplos

     .  Este ejemplo muestra la relaci.n que existe entre una variable
        privada y una variable campo que tienen el mismo nombre. La variable
        privada se declara con la sentencia MEMVAR:

        FUNCTION Ejemplo
           MEMVAR cantidad, direccion
           PRIVATE cantidad := 100
           USE Cliente NEW
           //
           ? cantidad         // Se refiere a la variable
                              // privada cantidad
           ? Cliente->Cantidad
                              // Se refiere a la variable de
                              // campo Cantidad
           //
           RETURN NIL

PARAMETERS
 Crea variables privadas donde se recibirán parámetros
------------------------------------------------------------------------------
 Sintaxis

     PARAMETERS <idLista privadas>

 Argumentos

     <idLista privadas> es una o más variables de parámetro, separadas
     por comas. El número de variables receptoras no tiene que ser igual al
     de argumentos pasados por el procedimiento o función que lo invoca.

 Descripción

     La sentencia PARAMETERS crea variables privadas que reciben los valores
     o referencias pasados. Las variables receptoras se denominan parámetros.
     Los valores o referencias realmente pasados por una llamada a un
     procedimiento o función se denominan argumentos.

     Cuando se ejecuta una sentencia PARAMETERS, todas las variables de la
     lista de parámetros se crean como variables privadas y todas las
     variables públicas o privadas que tengan el mismo nombre se ocultan
     hasta que finalice el proceso o función actual. La sentencia PARAMETERS
     es una sentencia ejecutable y puede aparecer en cualquier parte de un
     procedimiento o función, pero siempre después de las declaraciónes de
     variables de compilación, como FIELD, LOCAL, MEMVAR y STATIC.

     Los parámetros también pueden declararse como variablesólocales si se
     especifican como parte de una declaración PROCEDURE o FUNCTION (consulte
     el ejemplo). Los parámetros que se especifiquen de esta forma se
     denominan parámetros formales. Recuerde que en una definición de función
     o procedimiento no pueden especificarse simultáneamente parámetros
     formales y sentencias PARAMETERS. Si intenta hacerlo, se producirá un
     error fatal de compilación y no se generará el fichero objeto.

     En CA-Clipper, el número de argumentos no tiene que ser igual al número
     de parámetros. Si se especifican más argumentos que parámetros, se
     ignoran los argumentos restántes. Si se especifican menos argumentos que
     parámetros, a los restántes parámetros se les asigna el valor NIL. Si se
     omite un argumento, el parámetro correspondiente se inicializa con un
     valor NIL. La función PCOUNT() devuelve la posición del último argumento
     pasado en la lista de argumentos. Esta posición no es igual al número de
     parámetros pasados, ya que incluye los parámetros omitidos.

     Si desea más información sobre el modo de pasar parámetros, consulte el
     apartado funciónes y Procedimientos del capítulo Conceptos Básicos de la
     guía de Programación y Utilidades.

 Ejemplos

     .  Esta función definida por el usuario recibe valores pasados
        como parámetros privados con una sentencia PARAMETERS:

        FUNCTION Mifunción
           PARAMETERS cUno, cDos, cTres
           ? cUno, cDos, cTres
           RETURN NIL

     .  Este ejemplo es similar al anterior, pero recibe valores
        pasados como variablesólocales, declarando las variables de
        parámetros en la declaración FUNCTION:

        FUNCTION Mifunción( cUno, cDos, cTres )
           ? cUno, cDos, cTres
           RETURN NIL

PRIVATE
 Crea e inicializa matrices y variables de memoria privadas
------------------------------------------------------------------------------
 Sintaxis

     PRIVATE <identificador> [[:= <inicializador>], ... ]

 Argumentos

     <identificador> es el nombre de la variable o matriz privada que se
     va a crear. Si <identificador> va seguido de corchetes ([ ]), se crea
     una matriz y se asigna a <identificador>. Si <identificador> se
     especifica como una matriz, la sintaxis para indicar el número de
     elementos de cada dimensión puede ser matriz[<nElementos>,
     <nElementos2>,...] o matriz[<nElementos>][<nElementos2>]... El número
     máximo de elementos por dimensión es 4096. El número máximo de
     dimensiónes sólo depende de la cantidad de memoria disponible.

     <inicializador> es el valor que se asigna opciónalmente a la nueva
     variable privada. No es posible asignar valores a una matriz con
     <inicializador>. El <inicializador> para una variable privada est.
     formado por el operador de asignación en línea (:=) seguido de cualquier
     expresión víaacute;lida de CA-Clipper, incluyendo matrices literales. Si no se
     especifica un <inicializador>, la variable se inicializa con el valor
     NIL. Con una matriz, todos sus elementos se inicializa con el valor NIL.

     Es posible crear y, opciónalmente, inicializar una lista de variables y
     matrices en la misma sentencia PRIVATE, separando las definiciónes
     mediante comas.

 Descripción

     La sentencia PRIVATE crea variables y matrices que sólo son visibles
     dentro de los procedimientos y funciónes que las crean y las invocadas
     por ellas. La clase de almacenamiento PRIVATE es de ámbito dinámico. Las
     variables privadas existen mientras el procedimiento que las cre. no
     finalice o hasta que se liberan explícitamente con CLEAR ALL, CLEAR
     MEMORY o RELEASE. Al crear una matriz o variable privada, las variables
     privadas y públicas visibles que tengan el mismo nombre se ocultan hasta
     que termine el procedimiento o función actual.

     Si se intenta especificar una variable PRIVATE en conflicto con una
     declaración FIELD, LOCAL o STATIC del mismo nombre se produce un error
     fatal de compilación, independientemente del ámbito de la declaración.

     Las sentencias PRIVATE son sentencias ejecutables, por lo que deben
     especificarse en el cuerpo del procedimiento o función después de todas
     las declaraciónes de variables, como FIELD, LOCAL, MEMVAR y STATIC.

     Además de la sentencia PRIVATE, también pueden crearse variables
     privadas de estas dos formas:

     .  Una asignación de una variable inexistente o no visible crear.
        una variable privada

     .  Los parámetros recibidos con la sentencia PARAMETERS se crean
        como variables privadas con la misma visibilidad y tiempo de vida

     No puede haber más de 2048 matrices y variables públicas y privadas
     dentro de un mismo programa.

     Si desea más información sobre las declaraciónes de variables y su
     ámbito, consulte el apartado Variables del capítulo Conceptos Básicos de
     la guía de Programación y Utilidades.

 Notas

     .  Compatibilidad: Las cláusulas ALL, LIKE y EXCEPT de la
        sentencia PRIVATE utilizada en otros dialectos dBASE no pueden
        utilizarse en CA-Clipper.

 Ejemplos

     .  Este ejemplo crea dos matrices y tres variables PRIVATE:

        PRIVATE aMatriz1[10], aMatriz2[20], var1, var2, var3

     .  Este ejemplo crea matrices privadas multidimensiónales
        utilizando las dos notaciones:

        PRIVATE aMatriz1[10][10][10], aMatriz2[10, 10, 10]

     .  Este ejemplo utiliza sentencias PRIVATE para crear e
        inicializar matrices y variables:

        PRIVATE aMatriz := { 1, 2, 3, 4 }, ;
              aMatriz2 := ARRAY(12, 24)
        PRIVATE cCar := SPACE(10), cColor := SETCOLOR()


PROCEDURE
 Declara un nombre de procedimiento y sus parámetros formales
------------------------------------------------------------------------------
 Sintaxis

     [STATIC] PROCEDURE <idProcedimiento> [(<idLista par.m>)]
        [FIELD <idLista campos> [IN <idAlias>]
        [LOCAL <identificador> [[:= <inicializador>], ... ]]
        [MEMVAR <lista identificadores>]
        [STATIC <identificador> [[:= <inicializador>], ... ]]
        .
        . <sentencias ejecutables>
        .
        [RETURN]

 Argumentos

     <idProcedimiento> es el nombre del procedimiento que se declara. Los
     nombres de procedimiento pueden tener cualquier longitud, pero sólo son
     significativosólos 10 primeros carácteres. Pueden contener cualquier
     combinación de letras, números o carácteres de subrayado, pero los
     subrayados iniciales están reservados.

     <idLista par.m> es la declaración de una o más variables de
     parámetro. Las variables especificadas en esta lista se declaran como
     locales.

     STATIC PROCEDURE declara un procedimiento que sólo puede invocarse
     por los otros procedimientos o funciónes declarados en el mismo módulo
     fuente (.prg).

     FIELD declara una lista de identificadores, <idLista campos>, que se
     van a utilizar como nombres de campo cuando se encuentren. Una cláusula
     IN que preceda al <idAlias> declarado, crea una referencia al .rea de
     trabajo correspondiente de la base de datos especificada.

     LOCAL declara y, opciónalmente, inicializa una lista de variables o
     matrices de visibilidad y duraci.n limitadas al procedimiento actual.

     <identificador>, <lista identificadores> es una etiqueta o etiquetas
     utilizadas como el nombre de la variable o matriz que se va a crear. Si
     <identificador> va seguido de corchetes ([ ]), se crea una matriz y se
     asigna a <identificador>. Si <identificador> se especifica como una
     matriz, la sintaxis para indicar el número de elementos de cada
     dimensión puede ser matriz[<nElementos>, <nElementos2>,...] o
     matriz[<nElementos>][<nElementos2>]... El número máximo de elementos por
     dimensión es 4096. El número máximo de dimensiónes sólo depende de la
     cantidad de memoria disponible.

     <inicializador> es el valor que se asigna opciónalmente a la nueva
     variable privada. No es posible asignar valores a una matriz con
     <inicializador>. El <inicializador> para una variable privada est.
     formado por el operador de asignación en línea (:=) seguido de cualquier
     expresión víaacute;lida de CA-Clipper, incluyendo matrices literales. Si no se
     especifica un <inicializador>, la variable se inicializa con el valor
     NIL. Con una matriz, todos sus elementos se inicializan con el valor
     NIL.

     MEMVAR declara una lista de identificadores, <lista
     identificadores>, que se utilizan como matrices o variables de memoria
     privadas o públicas cuando se encuentran.

     STATIC declara y, opciónalmente, inicializa una lista de variables
     de ámbito de visibilidad en el procedimiento actual y cuyo tiempo de
     vida es toda la aplicación.

     RETURN devuelve el control al procedimiento o función invocante. Si
     no se especifica RETURN, el control se devuelve a la rutina invocante al
     terminar la definición del procedimiento. En cualquier caso, el
     compilador finaliza la definición de procedimiento si encuentra otra
     sentencia PROCEDURE, FUNCTION o un carácter de fin de fichero.

 Descripción

     La sentencia PROCEDURE declara un procedimiento y una lista opciónal de
     variablesólocales para recibir los parámetros pasados por la rutina
     invocante. Un procedimiento es un subprograma compuesto por un grupo de
     declaraciónes y sentencias que se ejecutan cuando se escribe
     <idProcedimiento> seguido de un paréntesis inicial y final o mediante
     una sentencia DO. Una definición de procedimiento comienza con la
     sentencia PROCEDURE y finaliza en la siguiente sentencia PROCEDURE,
     sentencia FUNCTION o carácter de fin de fichero.

     Los procedimientos permiten encapsular bloques de código de c.lculo para
     mejorar la legibilidad y modularidad, aislar los cambios y ayudar a
     manejar programas complejos.

     En CA-Clipper, un procedimiento es id.ntico a una función definida por
     el usuario, excepto en que siempre devuelve NIL. Cada procedimiento debe
     comenzar con una sentencia PROCEDURE y puede contener una sentencia
     RETURN para devolver el control al procedimiento o función invocante.
     Sin embargo, la sentencia RETURN no es imprescindible. Las declaraciónes
     de procedimiento no pueden anidarse dentro de otras definiciónes de
     procedimiento.

     Hay dos clases de visibilidad de nombres de procedimiento. Los
     procedimientos visibles desde cualquier parte de un programa se
     denominan procedimientos p.blicos y se declaran dentro de una sentencia
     PROCEDURE. Los procedimientos sólo visibles en el módulo fuente (.prg)
     actual se denominan procedimientos estáticos y se declaran con una
     sentencia STATIC PROCEDURE. El ámbito de los procedimientos estáticos es
     todo el fichero.

     Los procedimientos estáticos son bastante .tiles por varias razones. En
     primer lugar, limitan la visibilidad a un procedimiento, restringiendo
     as. el acceso a ese procedimiento. Debido a esto, los subsistemas
     definidos en un mismo módulo fuente (.prg) pueden ofrecer un protocolo
     de acceso mediante una serie de procedimientos p.blicos y ocultar los
     detalles internos del subsistema mediante funciónes y procedimientos
     estáticos. En segundo lugar, las referencias a los procedimientos
     estáticos se resuelven durante la compilación por lo que tienen
     preferencia sobre las referencias a funciónes y procedimientos p.blicos
     que se resuelven durante el enlazado. Esto garantiza que, si existe en
     un módulo fuente un conflicto de nombres entre un procedimiento estático
     y un procedimiento o función p.blico, se ejecute la referencia al
     procedimiento estático.

     Si desea más información sobre los procedimientos, declaraciónes de
     variables y paso de parámetros, consulte el capítulo Conceptos Básicos
     de la guía de Programación y Utilidades.

 Notas

     .  Llamada a un procedimiento: En CA-Clipper, un
        procedimiento puede llamarse de dos formas. La primera, y preferible,
        es la convenci.n de llamada de funciónes. Este m.todo para invocar un
        procedimiento es id.ntico al que se utiliza para invocar una función,
        en una línea individual:

        <idProcedimiento>([<lista argumentos>])

        El segundo m.todo es la convenci.n de llamada mediante el mandato
        DO...WITH. Los dos m.todos difieren sólo en la forma de paso de
        parámetros por defecto. La convenci.n funciónal de llamada pasa las
        variables por valor, mientras que la convenci.n de llamada por
        mandato los pasa por referencia.

        Un procedimiento también puede invocarse con una expresión de alias,
        si va precedido de un alias y se invoca mediante la convenci.n de
        llamada de funciónes, tal como se indica a continúa.ión:

        <idAlias> ->(<idProcedimiento>(<lista argumentos>))

        Al invocarse con una expresión de alias, se selecciona el .rea de
        trabajo correspondiente a <idAlias>, se ejecuta el procedimiento y se
        vuelve a seleccionar el área de trabajo original. Al iguak que una
        expresión o función, un procedimiento puede estar incluido en una
        expresión de alias.

        En CA-Clipper, un procedimiento puede invocarse recursivamente. Esto
        significa que se puede llamar al procedimiento dentro de la misma
        definición de procedimiento.

     .  Par.metros: Los procedimientos, al igual que las funciónes
        definidas por el usuario, pueden recibir parámetros pasados por el
        procedimiento que los llam., por una función definida por el usuario
        o por la línea de mandato del DOS. Un parámetro es un lugar para un
        valor o una referencia. En CA-Clipper, existen dos formas de recibir
        parámetros: puede declararse una lista de nombres de variables
        locales como parte de la declaración PROCEDURE (parámetros formales)
        o puede especificarse una lista de variables privadas en una
        sentencia PARAMETERS independiente. Recuerde que no puede mezclarse
        una declaración de parámetros formales con una sentencia PARAMETERS.
        Si se intenta hacerlo, se produce un error de compilación.

        Los procedimientos reciben los parámetros en el mismo orden en el que
        se pasan. En CA-Clipper, el número de parámetros no tiene que ser
        igual al número de argumentos pasados. Los argumentos pueden omitirse
        o dejarse al final de la lista de argumentos. Un parámetro que no
        reciba un valor o referencia se inicializa con el valor NIL. Si se
        especifican argumentos, PCOUNT() devuelve la posición del último
        argumento pasado.

        Los parámetros especificados en un procedimiento pueden recibir
        argumentos pasados por valor o por referencia. El m.todo por defecto
        para las expresiónes y variables depende de la convenci.n de llamada.
        En la convenci.n de llamada de funciónes, el m.todo por defecto para
        pasar expresiónes y variables es por valor, incluyendo variables que
        contienen referencias a matrices y objetos. En la convenci.n de
        llamada de mandatos, el m.todo por defecto para pasar variables es
        por referencia, excepto para las variables de campo, que siempre se
        pasan por valor. Cuando se pasa una variable de campo, debe
        encerrarse entre paréntesis, a menos que se declare con la sentencia
        FIELD. En caso contrario, se produce un error de ejecución.

 Ejemplos

     .  Este ejemplo muestra el esquema de un procedimiento de
        CA-Clipper que utiliza variables de ámbito resoluble en compilación:

        PROCEDURE Esqueleto( cNombre, cClase, nHuesos, ;
                                nArticulaciones )
           LOCAL nHuesosTrans, aEnMano := {"cr.neo", ;
                                         "metacarpianos"}
           STATIC nContador := 0
           .
           . <sentencias ejecutables>
           .
           RETURN

     .  Este ejemplo determina si se ha omitido alg.n argumento
        compar.ndolo con NIL:

        PROCEDURE MiProc( param1, param2, param3 )
           IF param2 != NIL
              param2 := "valor por defecto"
           ENDIF
           .
           . <sentencias>
           .
           RETURN

     .  Este ejemplo invoca al procedimiento, ActualizarCantidad(),
        con una expresión de alias:

        USE Facturas NEW
        USE Cliente NEW
        Facturas->(ActualizarCantidad(Importe + Importe * nInteres))


PUBLIC
 Crea e inicializa matrices y variables de memoria públicas
------------------------------------------------------------------------------
 Sintaxis

     PUBLIC <identificador> [[:= <inicializador>], ... ]

 Argumentos

     <identificador> es el nombre de una matriz o variable pública que se
     va a crear. Si el <identificador> va seguido de corchetes ([ ]), se crea
     como matriz. Si el <identificador> es una matriz, la sintaxis para la
     especificación del número de elementos para cada dimensión puede ser
     matriz[<nElementos>, <nElementos2>,...] o
     matriz[<nElementos>][<nElementos2>]... El número máximo de elementos por
     dimensión es 4096. El número máximo de dimensiónes por matriz est.
     limitado .nicamente por la cantidad de memoria disponible.

     <inicializador> es la asignación opciónal de un valor a una nueva
     variable pública. No obstante, no es posible dar valores a los
     identificadores de matriz con el <inicializador>. Un <inicializador>
     para una variable pública consiste en el operador de asignación en línea
     (:=) seguido de cualquier expresión de CA-Clipper víaacute;lida, incluyendo una
     matriz en forma literal. Excepto en el caso de las matrices, si no se
     especifica <inicializador>, las variables públicas se inicializan en
     falso (.F.). Esta es una excepci.n a la regla general de que las
     variables sin inicializar son valores NIL. En el caso de las matrices,
     sin embargo, el valor inicial de todos los elementos es NIL.

     Puede crearse una lista de variables y matrices y, opciónalmente,
     inicializarla con una sentencia PUBLIC, si las definiciónes están
     separadas por comas.

 Descripción

     La sentencia PUBLIC crea variables y matrices visibles para todos los
     procedimientos y funciónes definidas por el usuario de un programa. Las
     variables públicas existen durante todo el programa o hasta que se
     liberan explícitamente con CLEAR ALL, CLEAR MEMORY o RELEASE. La
     declaración de matrices o variables privadas, locales o estáticas con el
     mismo nombre que las variables públicas existentes oculta temporalmente
     estas variables públicas hasta que las variables que las solapan se
     liberan o dejan de estar visibles. Los intentos de crear una  variable
     pública con el mismo nombre que una variable privada visible y existente
     simplemente se ignoran (consulte las Notas de la siguiente p.gina para
     ver una excepci.n).

     Los intentos de especificar una variable pública que entre en conflicto
     con una declaración FIELD, LOCAL o STATIC prevía del mismo nombre dan
     como resultado un error de compilador fatal. Esto es as.,
     independientemente del ámbito de la declaración.

     Las sentencias PUBLIC son sentencias ejecutables y, por tanto, deben
     especificarse dentro de una definición de procedimiento o función
     definida por el usuario. Asimismo, deben ir detrás de todas las
     declaraciónes de compilación, tales como FIELD, LOCAL, MEMVAR y STATIC.

     El número máximo de matrices y variables públicas y privadas que pueden
     existir simultáneamente en un mismo programa es de 2048.

     Si desea más información sobre las declaraciónes de variable y su
     ámbito, consulte el apartado Variables del capítulo Conceptos Básicos de
     la guía de Programación y Utilidades.

 Notas

     .  Clipper PUBLIC: Para incluir extensiónes de CA-Clipper en
        un programa y, no obstante, permitir que el programa se ejecute en
        dBASE III PLUS, la variable pública especial Clipper se inicializa en
        verdadero (.T.) cuando se crea como PUBLIC.

     .  Nombre de matriz pública entra en conflicto con variables
      privadas existentes: La sentencia PUBLIC x[10] no crear. la matriz
        pública x si ya existe una variable privada o pública x. Sin embargo,
        destruye el contenido de la x existente, sustituy.ndola por una
        referencia a una matriz de diez elementos.

 Ejemplos

     .  Este ejemplo crea dos matrices públicas y una variable
        pública:

        PUBLIC aMatriz1[10, 10], var2
        PUBLIC aMatriz2[20][10]

     .  La siguiente sentencia PUBLIC crea variables y las inicializa
        con valores:

        PUBLIC cCadena := SPACE(10), cColor := SETCOLOR()
        PUBLIC aMatriz := {1, 2, 3}, aMatriz2 := ARRAY(12, 24)


REQUEST
 Declara una lista de enlazado de módulos
------------------------------------------------------------------------------
 Sintaxis

     REQUEST <idLista módulos>

 Argumentos

     <idLista módulos> es la lista de los módulos que se van a enlazar en
     el fichero ejecutable (.EXE) actual.

 Descripción

     REQUEST es una declaración que define una lista de identificadores de
     módulo para el enlazador. Al igual que las restántes declaraciónes, las
     sentencias REQUEST deben especificarse antes que cualquier sentencia
     ejecutable, ya sea en el módulo fuente, o en una definición de
     procedimiento o función.

     Durante la compilación del código fuente, todas las referencias
     expl.citas a procedimientos y funciónes se pasan al enlazador. En
     algunos casos, en un fichero fuente puede no hacerse referencias a
     nombres de procedimientos o funciónes hasta la ejecución. REQUEST
     resuelve esta situaci.n forzando el enlazado de los procedimientos y
     funciónes nombrados, incluso si existe una referencia expl.cita a ellos
     en el fichero fuente. Esto es importante en los siguientes casos:

     .  Procedimientos, funciónes o formatos referenciados por
        macroexpresiónes o variables que las contengan.

     .  Procedimientos y funciónes útilizadas en REPORT y LABEL FORM
        sin referencias en el código fuente

     .  funciónes útilizadas en claves de índice y sin referencias en
        el código fuente

     .  funciónes de usuario ACHOICE(), DBEDIT() o MEMOEDIT()

     .  Procedimientos de inicializaci.n declarados con la sentencia
        INIT PROCEDIMIENTO

     .  Procedimientos de clausura declarados con la sentencia EXIT
        PROCEDIMIENTO

     Para agrupar sentencias REQUEST comunes, col.quelas en un fichero de
     cabecera y, a continúa.ión, incluya el fichero de cabecera en todos los
     módulos fuente (.prg) que podr.an utilizarlas indirectamente.

 Ejemplos

     .  Este ejemplo muestra un fichero de cabecera t.pico que
        contiene sentencias REQUEST comunes para mandatos REPORT FORM:

        // Request.ch

        REQUEST HARDCR
        REQUEST TONE
        REQUEST MEMOTRAN
        REQUEST STRTRAN


RETURN
 Finaliza un procedimiento, función o programa
------------------------------------------------------------------------------
 Sintaxis

     RETURN [<exp>]

 Argumentos

     <exp> es una expresión de cualquier tipo que da como resultado el
     valor de retorno para funciónes de usuario. Si una función finaliza sin
     una sentencia RETURN, el valor de retorno es NIL.

 Descripción

     RETURN finaliza un procedimiento, función o programa, devolviendo el
     control al procedimiento o función que la invoc.. Si se ejecuta un
     RETURN en el procedimiento de nivel m.s alto, el control pasa al sistema
     operativo. Al devolverse el control al procedimiento llamante, se
     liberan todas las variables privadas creadas y las variablesólocales
     declaradas en el procedimiento o función actual.

     En un procedimiento o función puede haber más de una sentencia RETURN.
     Aunque no es imprescindible que termine en dicha sentencia, como todas
     las funciónes deben devolver un valor, la función debe contener al menos
     una sentencia RETURN con un argumento.

     Nota: Una definición de procedimiento o función finaliza al
     encontrarse la siguiente sentencia PROCEDIMIENTO, FUNCTION o carácter de
     fin de fichero, no al encontrarse una sentencia RETURN

 Notas

     .  Matrices: Las matrices son un tipo de datos como otro
        cualquiera, las apariciones de matrices son realmente valores como
        cadenas de carácteres y, por tanto, pueden devolverse desde una
        función.

     .  RETURN TO MASTER: CA-Clipper no permite la utilización de
        RETURN TO MASTER ni las dem.s formas de RETURN que especifican el
        nivel al que debe devolverse el control. Sin embargo, es posible
        simular estas operación.s con BEGIN SEQUENCE...END.

 Ejemplos

     .  Estos ejemplos muestran el formato general de la sentencia
        RETURN en un procedimiento y en una función :

        PROCEDIMIENTO <idProcedimiento>
           //
           <sentencias>...
           //
           RETURN

        FUNCTION <idfunción>
           //
           <sentencias>...
           //
           RETURN <expDevuelto>

     .  Este ejemplo devuelve una matriz creada en una función al
        procedimiento o función que la ha invocado:

        FUNCTION DevolverMatriz
           PRIVATE aMatriz[10][10]
           aMatriz[1][1] = "miCadena"
           RETURN aMatriz


STATIC
 Declara e inicializa variables y matrices estáticas
------------------------------------------------------------------------------
 Sintaxis

     STATIC <identificador> [[:= <inicializador>], ... ]

 Argumentos

     <identificador> es el nombre de la variable o matriz que debe
     declararse como estática. Si el <identificador> va seguido de corchetes
     ([ ]), se crea como una matriz. Si el <identificador> es una matriz, la
     sintaxis para especificar el número de elementos para cada dimensión
     puede ser matriz[<nElementos>, <nElementos2>,...] o matriz[<nElementos>]
     [<nElementos2>]... El número máximo de elementos por dimensión es 4096.
     El número máximo de dimensiónes está limitado sólo por la memoria
     disponible.

     <inicializador> es la asignación opciónal de un valor a una nueva
     variable estática. Un <inicializador> para una variable estática consta
     de una operador de asignación en línea (:=) seguido de una expresión
     constante de tiempo de compilación formada por constantes y operadores o
     una matriz en forma literal. Si no se especifica un <inicializador>
     explícito, se asigna a la variable un valor inicial de NIL. En el caso
     de una matriz, cada uno de sus elementos es NIL. No pueden asignarse
     valores a los identificadores de matrices con un <inicializador>.

     Nota:  El operador de macro (&) no puede utilizarse en una sentencia
     STATIC.

 Descripción

     La sentencia STATIC declara variables y matrices que tienen un tiempo de
     vida igual al de programa pero que sólo son visibles dentro de la
     entidad que las crea. Estas variables sólo son visibles dentro de un
     procedimiento o función si se declaran después de una sentencia
     PROCEDURE o FUNCTION. Las variables estáticas son visibles para todos
     los procedimientos y funciónes de un módulo fuente (.pgr) (es decir,
     tienen un ámbito a nivel de módulo) si se declaran antes de la primera
     definición de procedimiento o función del fichero. Utilice la opción de
     compilador /N para compilar un programa cuyas variables tengan ámbito a
     nivel de módulo.

     Todas las variables estáticas de un programa se crean cuando se invoca
     al programa por primera vez y todos los valores especificados en un
     <inicializador> estático se asignan a la variable antes del inicio de la
     ejecución del programa.

     Las declaraciónes de variables estáticas dentro de un procedimiento o
     función definida por el usuario deben producirse antes de cualquier
     sentencia ejecutable incluyendo PRIVATE, PUBLIC y PARAMETERS. Si se
     declara una variable del mismo nombre FIELD, LOCAL o MEMVAR dentro de un
     procedimiento o función, se produce un error de compilación y no se
     genera ningún fichero objeto (.OBJ).

     El número máximo de variables estáticas de un programa está limitado
     solamente por la memoria disponible.

 Notas

     .  Inspección de variables estáticas dentro del Depurador:
        Para acceder a los nombres de las variables estáticas dentro del
        Depurador de     CA-Clipper, debe compilar los módulos fuente (.prg)
        utilizando la opción /B de modo que la información sobre variables
        estáticas se incluya en el fichero objeto (.OBJ).

     .  Macroexpresiónes: No debe hacer referencia a variables
        estáticas dentro de macroexpresiónes o variables que las contengan.
        Si as. lo hace, se intentar. acceder a una variable privada o pública
        que tenga el mismo nombre. Si no existe tal variable, se genera un
        error de ejecución.

     .  Ficheros de memoria: Las variables estáticas no pueden
        guardarse ni recuperarse de ficheros de memoria (.mem).

     .  Tipo de una variable local estática: Puesto que TYPE()
        utiliza el operador de macro (&) para evaluar su argumento, no puede
        utilizar esta función para determinar el tipo de una variable local o
        estática o de una expresión que contenga una referencia a variable
        local o estática. La función VALTYPE() ofrece esta posibilidad
        evaluando el argumento de la función y devolviendo el tipo de datos
        de su valor de retorno.

 Ejemplos

     .  Este ejemplo declara variables estáticas con y sin
        inicializadores:

        STATIC aMatriz1[20, 10], aMatriz2[20][10]
        STATIC cVar, cVar2
        STATIC cCadena := "mi cadena", var
        STATIC aMatriz := {1, 2, 3}

     .  Este ejemplo maneja una variable estática dentro de una
        función definida por el usuario. En este ejemplo, una variable de
        contador se incrementa a s. misma cada vez que se llama a la función:

        FUNCTION MiContador( nValorNuevo )
           STATIC nContador := 0        // Valor inicial asignado una vez
           IF nValorNuevo != NIL
              nContador:= nValorNuevo   // Valor nuevo para nContador
           ELSE
              nContador++               // Incremento nContador
           ENDIF
           RETURN nContador

     .  Este ejemplo muestra una declaración de variable estática que
        tiene ámbito a nivel de módulo. En este fragmento de código, aMatriz
        es visible para los dos procedimientos que siguen a la declaración:

        STATIC aMatriz := {1, 2, 3, 4}

        FUNCTION Uno
           ? aMatriz[1]                 // Resultado: 1
           RETURN NIL

        FUNCTION Dos
           ? aMatriz[3]                 // Resultado: 3
           RETURN NIL

 

 

Solo personas registradas pueden poner comentarios