*** empty log message ***
This commit is contained in:
Alejandro de Garate
@@ -8,6 +8,27 @@
|
||||
2002-12-01 23:12 UTC+0100 Foo Bar <foo.bar@foobar.org>
|
||||
*/
|
||||
|
||||
2003-07-13 14:08 UTC-0400 Alejandro de Garate <alex_degarate@hotmail.com>
|
||||
* doc/es/Makefile
|
||||
+ gnulice.txt
|
||||
+ hvm.txt
|
||||
+ input.txt
|
||||
+ macro.txt
|
||||
+ memvar2.txt
|
||||
+ misc.txt
|
||||
+ nation.txt
|
||||
+ objfunc.txt
|
||||
+ rdd.txt
|
||||
+ sayget.txt
|
||||
+ subcodes.txt
|
||||
+ tbrowse.txt
|
||||
+ tclass.txt
|
||||
+ tgetlist.txt
|
||||
+ tlabel.txt
|
||||
+ treport.txt
|
||||
+ var.txt
|
||||
+ Added references to new doc files
|
||||
|
||||
2003-07-13 12:32 UTC-0400 Alejandro de Garate <alex_degarate@hotmail.com>
|
||||
* doc/es/lang.txt
|
||||
! Fixed accents, etc, minor formating. Now in sync with english version
|
||||
|
||||
@@ -7,41 +7,42 @@ ROOT = ../../
|
||||
DOC_SUBDIR=/es
|
||||
|
||||
DOC_FILES=\
|
||||
array.txt \
|
||||
binnum.txt \
|
||||
browse.txt \
|
||||
clipper.txt \
|
||||
cmdline.txt \
|
||||
codebloc.txt \
|
||||
command.txt \
|
||||
compiler.txt \
|
||||
datetime.txt \
|
||||
dbdelim.txt \
|
||||
dbsdf.txt \
|
||||
dbstrux.txt \
|
||||
dir.txt \
|
||||
dirstruc.txt \
|
||||
diskspac.txt \
|
||||
error.txt \
|
||||
eval.txt \
|
||||
garbage.txt \
|
||||
harbext.txt \
|
||||
hb_set.txt \
|
||||
hbpplib.txt \
|
||||
howtobsd.txt \
|
||||
idle.txt \
|
||||
lang.txt \
|
||||
license.txt \
|
||||
math.txt \
|
||||
memo.txt \
|
||||
pcode.txt \
|
||||
pragma.txt \
|
||||
readme.txt \
|
||||
setmode.txt \
|
||||
simplex.txt \
|
||||
statics.txt \
|
||||
strotype.txt \
|
||||
tracing.txt \
|
||||
vm.txt \
|
||||
array.txt \
|
||||
binnum.txt \
|
||||
browse.txt \
|
||||
clipper.txt \
|
||||
cmdline.txt \
|
||||
codebloc.txt \
|
||||
command.txt \
|
||||
compiler.txt \
|
||||
datetime.txt \
|
||||
dbdelim.txt \
|
||||
dbsdf.txt \
|
||||
dbstrux.txt \
|
||||
dir.txt \
|
||||
dirstruc.txt \
|
||||
diskspac.txt \
|
||||
error.txt \
|
||||
eval.txt \
|
||||
garbage.txt \
|
||||
harbext.txt \
|
||||
hb_set.txt \
|
||||
hbpplib.txt \
|
||||
howtobsd.txt \
|
||||
idle.txt \
|
||||
lang.txt \
|
||||
license.txt \
|
||||
math.txt \
|
||||
memo.txt \
|
||||
pcode.txt \
|
||||
pragma.txt \
|
||||
readme.txt \
|
||||
setmode.txt \
|
||||
simplex.txt \
|
||||
statics.txt \
|
||||
strotype.txt \
|
||||
tracing.txt \
|
||||
vm.txt \
|
||||
|
||||
include $(TOP)$(ROOT)config/doc.cf
|
||||
|
||||
|
||||
500
harbour/doc/es/gnulice.txt
Normal file
500
harbour/doc/es/gnulice.txt
Normal file
@@ -0,0 +1,500 @@
|
||||
/*
|
||||
* $Id$
|
||||
*/
|
||||
|
||||
/* $DOC$
|
||||
* $FUNCNAME$
|
||||
* Licencia GNU
|
||||
* $CATEGORY$
|
||||
* Documento
|
||||
* $ONELINER$
|
||||
* Licencia GNU Parte 1
|
||||
* $DESCRIPTION$
|
||||
*
|
||||
* GNU General Public License </par>
|
||||
* Licencia P£blica General
|
||||
* Versi¢n 2, Junio de 1991 </par>
|
||||
*
|
||||
* Copyright (C) 1989, 1991 Free Software Foundation, Inc.
|
||||
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA </par>
|
||||
*
|
||||
* -----------------------------------------------------------------
|
||||
*
|
||||
* Traducci¢n al Espa¤ol : Diciembre de 2001 por
|
||||
* Jos‚ Mar¡a Sar chaga Fischer <jsarachaga@garaitia.com>
|
||||
* Contribuciones:
|
||||
* 13-Dic-2002 Fabi n Rodr¡guez <fabian.rodriguez@toxik.com>
|
||||
* Ene 2003 Alejandro de G rate <alex_degarate@hotmail.com>
|
||||
*
|
||||
* This is an unofficial translation of the GNU General Public
|
||||
* License into spanish. It was not published by the Free Software
|
||||
* Foundation, and does not legally state the distribution terms for
|
||||
* software that uses the GNU GPL--only the original English text of
|
||||
* the GNU GPL does that. However, we hope that this translation
|
||||
* will help spanish speakers understand the GNU GPL better.
|
||||
*
|
||||
* -----------------------------------------------------------------
|
||||
*
|
||||
* Esta es una traducci¢n NO oficial de la "GNU General Public
|
||||
* License" al espa¤ol. No fu‚ publicada por la "FSF Free Software
|
||||
* Foundation", y no respalda legalmente los t‚rminos de
|
||||
* distribuci¢n del software que utiliza la "GNU GPL", s¢lo el texto
|
||||
* original en ingl‚s lo hace. Sin embargo esperamos que esta
|
||||
* traducci¢n ayude a las personas de habla hispana a entender mejor
|
||||
* la "GPL".
|
||||
*
|
||||
* -----------------------------------------------------------------
|
||||
*
|
||||
* Toda persona tiene permiso de copiar y distribuir copias fieles
|
||||
* de este documento de licencia, pero no se permite hacer
|
||||
* modificaciones.
|
||||
*
|
||||
*
|
||||
* <b>PREAMBULO</b>
|
||||
*
|
||||
* Los contratos de licencia de la mayor parte del software est n
|
||||
* dise¤ados para quitarle su libertad de compartir y modificar
|
||||
* dicho software. En contraste, la "GNU General Public License"
|
||||
* pretende garantizar su libertad de compartir y modificar el
|
||||
* software "libre", esto es para asegurar que el software es libre
|
||||
* para todos sus usuarios. Esta licencia p£blica general se aplica
|
||||
* a la mayor¡a del software de la "FSF Free Software Foundation"
|
||||
* (Fundaci¢n para el Software Libre) y a cualquier otro programa de
|
||||
* software cuyos autores as¡ lo establecen. Algunos otros programas
|
||||
* de software de la Free Software Foundation est n cubiertos por la
|
||||
* "LGPL Library General Public License" (Licencia P£blica General
|
||||
* para Librer¡as), la cual puede aplicar a sus programas tambi‚n.
|
||||
*
|
||||
* Cuando hablamos de software libre, nos referimos a libertad, no
|
||||
* precio. Nuestras licencias "General Public Licenses" est n
|
||||
* dise¤adas para asegurar que:
|
||||
*
|
||||
* 1. usted tiene la libertad de distribuir copias del software
|
||||
* libre (y cobrar por ese sencillo servicio si as¡ lo desea)
|
||||
* 2. recibir el c¢digo fuente (o tener la posibilidad de obtenerlo
|
||||
* si as¡ lo desea)
|
||||
* 3. que usted puede modificar el software o utilizar partes de
|
||||
* ‚l en nuevos programas de software libre
|
||||
* 4. que usted est‚ enterado de que tiene la posibilidad de hacer
|
||||
* todas estas cosas.
|
||||
*
|
||||
* Para proteger sus derechos, necesitamos hacer restricciones que
|
||||
* prohiban a cualquiera denegarle estos derechos o a pedirle que
|
||||
* renuncie a ellos. Estas restricciones se traducen en algunas
|
||||
* responsabilidades para usted, si distribuye copias del software,
|
||||
* ¢ si lo modifica.
|
||||
*
|
||||
* Por ejemplo, si usted distribuye copias de un programa, ya sea
|
||||
* gratuitamente o por alg£n importe, usted debe dar al que recibe
|
||||
* el software todos los derechos que usted tiene sobre el mismo.
|
||||
* Debe asegurarse tambi‚n que reciban el c¢digo fuente o bi‚n que
|
||||
* puedan obtenerlo si lo desean. Y por £ltimo debe mostrarle a esa
|
||||
* persona estos t‚rminos, para que conozca los derechos de que goza.
|
||||
*
|
||||
* Nosotros protegemos sus derechos en 2 pasos: (1) protegiendo los
|
||||
* derechos de autor del software y (2) ofreciendole este contrato
|
||||
* de licencia que le otorga permiso legal para copiar, distribuir
|
||||
* y modificar el software.
|
||||
*
|
||||
* Adem s, para la protecci¢n de los autores de software y la
|
||||
* nuestra, queremos asegurarnos de que toda persona entienda que no
|
||||
* existe ninguna garant¡a del software libre. Si el software es
|
||||
* modificado por alguien y lo distribuye, queremos que quienes lo
|
||||
* reciban sepan que la copia que obtuvieron no es la original, por
|
||||
* lo que cualquier problema provocado por quien realiz¢ la
|
||||
* modificaci¢n no afectar la reputaci¢n del autor original.
|
||||
*
|
||||
* Finalmente, cualquier programa de software libre es constantemente
|
||||
* amenazado por las patentes de software. Deseamos evadir el peligro
|
||||
* de que los re-distribuidores de un programa de software libre
|
||||
* obtenga individualmente los derechos de patente con el fin de
|
||||
* volver dicho programa propietario. Para prevenir esto, hemos
|
||||
* dejado en claro que cualquier patente deber ser licenciada para
|
||||
* el uso libre de toda persona o que no est‚ licenciada del todo.
|
||||
*
|
||||
* A continuaci¢n se describen con precisi¢n los t‚rminos y
|
||||
* condiciones para copiar, distribuir y modificar el software.
|
||||
*
|
||||
* -----------------------------------------------------------------
|
||||
*
|
||||
*
|
||||
* <b>TERMINOS Y CONDICIONES PARA COPIA, MODIFICACION Y DISTRIBUCION</b>
|
||||
*
|
||||
* 0. Esta licencia aplica a cualquier programa o trabajo que
|
||||
* contenga una nota puesta por el propietario de los derechos del
|
||||
* trabajo estableciendo que su trabajo puede ser distribuido bajo
|
||||
* los t‚rminos de esta "GPL General Public License".
|
||||
* El "Programa", utilizado en lo subsecuente, se refiere a
|
||||
* cualquier programa o trabajo original, y el "trabajo basado en
|
||||
* el Programa" significa ya sea el Programa o cualquier trabajo
|
||||
* derivado del mismo bajo la ley de derechos de autor: es decir,
|
||||
* un trabajo que contenga el Programa o alguna porci¢n de ‚l, ya
|
||||
* sea ¡ntegra o con modificaciones y/o traducciones a otros idiomas.
|
||||
* De aqu¡ en adelante "traducci¢n" estar incluida (pero no
|
||||
* limitada a) en el t‚rmino "modificaci¢n", y la persona a la que
|
||||
* se aplique esta licencia ser llamado "usted".
|
||||
*
|
||||
* Otras actividades que no sean copia, distribuci¢n o
|
||||
* modificaci¢n no est n cubiertas en esta licencia y est n fuera de
|
||||
* su alcance. El acto de ejecutar el programa no est restringido,
|
||||
* y la salida de informaci¢n del programa est cubierta s¢lo si su
|
||||
* contenido constituye un trabajo basado en el Programa (es
|
||||
* independiente de si fue resultado de ejecutar el programa). Si
|
||||
* esto es cierto ¢ no depende de la funci¢n del programa.
|
||||
*
|
||||
*
|
||||
* 1. Usted puede copiar y distribuir copias fieles del c¢digo
|
||||
* fuente del programa tal como lo recibi¢, en cualquier medio,
|
||||
* siempre que proporcione de manera conciente y apropiada una nota
|
||||
* de derechos de autor y una declaraci¢n de no garant¡a, adem s de
|
||||
* mantener intactas todas las notas que se refieran a esta licencia
|
||||
* y a la ausencia de garant¡a, y que le proporcione a las dem s
|
||||
* personas que reciban el programa una copia de esta licencia junto
|
||||
* con el Programa.
|
||||
* Usted puede aplicar un cargo por el acto f¡sico de transferir una
|
||||
* copia, y ofrecer protecci¢n de garant¡a por una cuota, lo cual no
|
||||
* compromete a que el autor original del Programa responda por tal
|
||||
* efecto.
|
||||
*
|
||||
*
|
||||
* 2. Usted puede modificar su copia del Programa o de cualquier
|
||||
* parte de el, formando as¡ un trabajo basado en el Programa, y
|
||||
* copiar y distribuir tales modificaciones o bi‚n trabajar bajo los
|
||||
* t‚rminos de la secci¢n 1 arriba descrita, siempre que cumpla con
|
||||
* las siguientes condiciones:
|
||||
*
|
||||
* A. Usted debe incluir en los archivos modificados notas
|
||||
* declarando que modific¢ dichos archivos y la fecha de los
|
||||
* cambios.
|
||||
* B. Usted debe notificar que ese trabajo que distribuye contiene
|
||||
* totalmente o en partes al Programa, y que debe ser licenciado
|
||||
* como un conjunto sin cargo alguno a cualquier otra persona
|
||||
* que reciba sus modificaciones bajo los t‚rminos de esta
|
||||
* Licencia.
|
||||
* C. Si el programa modificado lee normalmente comandos
|
||||
* interactivamente cuando es ejecutado, usted debe presentar un
|
||||
* aviso, cuando el programa inicie su ejecuci¢n en ese modo
|
||||
* interactivo de la forma m s ordinaria, que contenga una nota
|
||||
* de derechos de autor y un aviso de que no existe garant¡a
|
||||
* alguna (o que s¡ existe si es que usted la proporciona) y que
|
||||
* los usuarios pueden redistribuir el programa bajo esas
|
||||
* condiciones, e informando al usuario como puede ver una copia
|
||||
* de esta Licencia. (Excepci¢n: si el programa en s¡ es
|
||||
* interactivo pero normalmente no muestra notas, su trabajo
|
||||
* basado en el Programa no tiene la obligaci¢n de mostrar tales
|
||||
* notas)
|
||||
*
|
||||
* Estos requerimientos aplican al trabajo modificado como un todo.
|
||||
* Si existen secciones identificables de tal trabajo que no son
|
||||
* derivadas del Programa original, y pueden ser razonablemente
|
||||
* consideradas trabajos separados e independientes como tal,
|
||||
* entonces esta Licencia y sus t‚rminos no aplican a dichas
|
||||
* secciones cuando usted las distribuye como trabajos separados.
|
||||
* Pero cuando usted distribuye las mismas secciones como parte de
|
||||
* un todo, que es un trabajo basado en el Programa, la distribuci¢n
|
||||
* del conjunto debe ser bajo los t‚rminos de esta Licencia, cuyos
|
||||
* permisos para otras personas que obtengan el software se
|
||||
* extienden para todo el software, as¡ como para cada parte de ‚l,
|
||||
* independientemente de qui‚n lo escribi¢.
|
||||
*
|
||||
* No es la intenci¢n de esta secci¢n de reclamar derechos o pelear
|
||||
* sus derechos sobre trabajos hechos enteramente por usted, en lugar
|
||||
* de eso, la intenci¢n es ejercer el derecho de controlar la
|
||||
* distribuci¢n de los trabajos derivados o colectivos basados en el
|
||||
* Programa.
|
||||
*
|
||||
* Adicionalmente, el simple agregado de otro trabajo NO basado en
|
||||
* el Programa al Programa en cuesti¢n (o a un trabajo basado en el
|
||||
* Programa) en alg£n medio de almacenamiento no pone el otro
|
||||
* trabajo bajo el alcance de esta Licencia.
|
||||
*
|
||||
*
|
||||
* 3. Usted puede copiar y distribuir el Programa (¢ un trabajo
|
||||
* basado en ‚l, bajo la Secci¢n 2) en c¢digo objeto ¢ en forma
|
||||
* de ejecutable bajo los t‚rminos de las secciones 1 y 2 arriba
|
||||
* descritas siempre que cumpla los siguientes requisitos:
|
||||
*
|
||||
* A. Acompa¤arlo con el correspondiente c¢digo fuente legible por
|
||||
* la m quina, que debe ser distribu¡do bajo los t‚rminos de las
|
||||
* secciones 1 y 2 y en un medio comunmente utilizado para el
|
||||
* intercambio de software, ¢
|
||||
* B. Acompa¤arlo con una oferta escrita, v lida por al menos 3
|
||||
* a¤os y para cualquier persona, por un cargo no mayor al costo
|
||||
* que conlleve la distribuci¢n f¡sica del c¢digo fuente
|
||||
* correspondiente en un medio comunmente utilizado para el
|
||||
* intercambio de software, ¢
|
||||
* C. Acompa¤arlo con la informaci¢n que usted recibi¢ sobre la
|
||||
* oferta de distribuci¢n del c¢digo fuente correspondiente.
|
||||
* (Esta alternativa est permitida s¢lo para distribuci¢n
|
||||
* no-comercial y s¢lo si usted recibi¢ el Programa en c¢digo
|
||||
* objeto o en forma de ejecutable con tal oferta de acuerdo
|
||||
* a la subsecci¢n b anterior)
|
||||
*
|
||||
* El c¢digo fuente de un trabajo significa la forma preferida de
|
||||
* hacer modificaciones al mismo. Para un trabajo ejecutable, un
|
||||
* c¢digo fuente completo significa todo el c¢digo fuente de todos
|
||||
* los m¢dulos que contiene, m s cualquier archivo de definici¢n de
|
||||
* interfases, m s los programas utilizados para controlar la
|
||||
* compilaci¢n y la instalaci¢n del ejecutable.
|
||||
* Sin embargo, como excepci¢n especial, no se requiere que el
|
||||
* c¢digo fuente distribu¡do incluya cualquier cosa que no sea
|
||||
* normalmente distribu¡da con las componentes mayores (compilador,
|
||||
* kernel, etc.) del sistema operativo en el cual el ejecutable
|
||||
* corre, a menos de que una componente en particular acompa¤e al
|
||||
* ejecutable.
|
||||
*
|
||||
* Si la distribuci¢n del ejecutable ¢ del c¢digo objeto se hace
|
||||
* ofreciendo acceso a copiar desde un lugar designado, entonces el
|
||||
* ofrecer acceso equivalente para copiar el c¢digo fuente desde el
|
||||
* mismo lugar se considera distribuci¢n del c¢digo fuente, aunque
|
||||
* las dem s personas no copien el c¢digo fuente junto con el c¢digo
|
||||
* objeto.
|
||||
*
|
||||
*
|
||||
* 4. Usted no puede copiar, modificar, sub-licenciar ni distribuir
|
||||
* el Programa a menos que sea expresamente bajo esta Licencia, de
|
||||
* otra forma cualquier intento de copiar, modificar, sub-licenciar
|
||||
* ¢ distribuir el programa es nulo, y autom ticamente causar la
|
||||
* p‚rdida de sus derechos bajo esta Licencia. Sin embargo, cualquier
|
||||
* persona que haya recibido copias ¢ derechos de usted bajo esta
|
||||
* Licencia no ver n terminadas sus Licencias ni sus derechos
|
||||
* perdidos mientras ellas contin£en cumpliendo los t‚rminos de
|
||||
* esta Licencia.
|
||||
*
|
||||
*
|
||||
* 5. Usted no est obligado a aceptar esta Licencia, dado que no la
|
||||
* ha firmado. Sin embargo, nada le otorga el permiso de modificar ¢
|
||||
* distribuir el Programa ni sus trabajos derivados. Estas acciones
|
||||
* est n prohibidas por la ley si usted no acepta esta Licencia.
|
||||
* Sin embargo, modificando o distribuyendo el Programa (o cualquier
|
||||
* trabajo basado en el Programa) indica su aceptaci¢n de esta
|
||||
* Licencia y de todos sus t‚rminos y condiciones para copiar,
|
||||
* distribuir o modificar el Programa y/o trabajos basados en ‚l.
|
||||
*
|
||||
*
|
||||
* 6. Cada vez que usted redistribuye el Programa (o cualquier
|
||||
* trabajo basado en el Programa), la persona que lo recibe
|
||||
* autom ticamente recibe una licencia del autor original para
|
||||
* copiar, distribuir o modificar el Programa sujeto a estos
|
||||
* t‚rminos y condiciones. Usted no puede imponer ninguna
|
||||
* restricci¢n adicional a las personas que reciban el Programa
|
||||
* sobre los derechos que en esta Licencia se les otorga.
|
||||
* Usted no es responsable de forzar a terceras personas en ‚l
|
||||
* cumplimiento de esta Licencia.
|
||||
*
|
||||
* $SEEALSO$
|
||||
* Licencia GNU Parte 2
|
||||
* $END$
|
||||
*/
|
||||
|
||||
/*
|
||||
* $DOC$
|
||||
* $FUNCNAME$
|
||||
* Licencia GNU Parte 2
|
||||
* $CATEGORY$
|
||||
* Documento
|
||||
* $ONELINER$
|
||||
* Licencia GNU Parte 2
|
||||
* $DESCRIPTION$
|
||||
*
|
||||
* 7. Si como consecuencia de un veredicto de un juzgado o por el
|
||||
* alegato de infringir una patente ¢ por cualquier otra raz¢n (no
|
||||
* limitado s¢lo a cuestiones de patentes) se imponen condiciones
|
||||
* sobre usted que contradigan los t‚rminos y condiciones de esta
|
||||
* Licencia, ‚stas no le excusan de los t‚rminos y condiciones aqu¡
|
||||
* descritos. Si usted no puede distribuir el producto cumpliendo
|
||||
* totalmente con las obligaciones concernientes a la resoluci¢n
|
||||
* oficial y al mismo tiempo con las obligaciones que se describen
|
||||
* en este contrato de Licencia, entonces no podr distribuir m s
|
||||
* este producto. Por ejemplo, si una licencia de patente no
|
||||
* permitir la distribuci¢n del Programa de forma libre de
|
||||
* regal¡as (sin pago de regal¡as) por parte de quienes lo reciban
|
||||
* directa o indirectamente, entonces la £nica forma de cumplir con
|
||||
* ambas obligaciones es renunciar a la distribuci¢n del mismo.
|
||||
*
|
||||
* Si cualquier parte de esta secci¢n resulta inv lida, inaplicable
|
||||
* ¢ no obligatoria bajo cualquier circunstancia en particular, la
|
||||
* tendencia de esta es a aplicarse, y la secci¢n completa se
|
||||
* aplicar bajo otras circunstancias.
|
||||
*
|
||||
* La intenci¢n de esta secci¢n no es la de inducirlo a infringir
|
||||
* ninguna ley de patentes, ni tampoco infringir alg£n reclamo de
|
||||
* derechos, ni discutir la validez de tales reclamos; esta secci¢n
|
||||
* tiene el £nico prop¢sito de proteger la integridad del sistema de
|
||||
* distribuci¢n del software libre, que est implementado por
|
||||
* pr cticas de licencia p£blica. Mucha gente ha hecho generosas
|
||||
* contribuciones a la amplia gama de software distribuido bajo este
|
||||
* sistema favoreciendo as¡ la constante aplicaci¢n de este sistema
|
||||
* de distribuci¢n; es decisi¢n del autor/donador si su Programa
|
||||
* ser distribu¡do utilizando este u otro sistema de distribuci¢n,
|
||||
* y la persona que recibe el software no puede obligarlo a hacer
|
||||
* ninguna elecci¢n en particular.
|
||||
* Esta secci¢n pretende dejar muy en claro lo que se cree que ser
|
||||
* una consecuencia del resto de esta Licencia.
|
||||
*
|
||||
*
|
||||
* 8. Si la distribuci¢n y/o el uso del Programa se restringe a
|
||||
* algunos pa¡ses ya sea por patentes, interfases protegidas por
|
||||
* derechos de autor, el propietario original de los derechos de
|
||||
* autor que ubica su Programa bajo esta Licencia puede agregar una
|
||||
* restricci¢n geogr fica de distribuci¢n expl¡cita excluyendo
|
||||
* los pa¡ses que aplique, dando como resultado que su distribuci¢n
|
||||
* s¢lo se permita en los pa¡ses no exclu¡dos. En tal caso, esta
|
||||
* Licencia incorpora la limitaci¢n como si hubiera sido escrita en
|
||||
* el cuerpo de esta misma Licencia.
|
||||
*
|
||||
*
|
||||
* 9. La "FSF Free Software Foundation" puede publicar versiones
|
||||
* nuevas o revisadas de la "GPL General Public License" de uno a
|
||||
* otro momento. Estas nuevas versiones mantendr n el esp¡ritu de la
|
||||
* presente versi¢n, pero pueden diferir en la inclusi¢n de nuevos
|
||||
* problemas ¢ en la manera de tocar los problemas ¢ aspectos ya
|
||||
* presentes.
|
||||
*
|
||||
* Cada versi¢n tendr un n£mero de versi¢n que la distinga. Si el
|
||||
* Programa especifica un n£mero de versi¢n para esta Licencia que
|
||||
* aplique a ‚l y "cualquier versi¢n subsecuente", usted tiene la
|
||||
* opci¢n de seguir los t‚rminos y condiciones de dicha versi¢n o de
|
||||
* cualquiera de las posteriores versiones publicadas por la "FSF".
|
||||
* Si el programa no especifica una versi¢n en especial de esta
|
||||
* Licencia, usted puede elegir entre cualquiera de las versiones
|
||||
* que han sido publicadas por la "FSF".
|
||||
*
|
||||
*
|
||||
* 10. Si usted desea incorporar partes del Programa en otros
|
||||
* Programas de software libre cuyas condiciones de distribuci¢n
|
||||
* sean distintas, deber escribir al autor solicitando su
|
||||
* autorizaci¢n. Para programas de software protegidas por la "FSF
|
||||
* Free Software Foundation", deber escribir a la "FSF" solicitando
|
||||
* autorizaci¢n, en ocasiones hacemos excepciones. Nuestra decisi¢n
|
||||
* ser guiada por dos metas principales:
|
||||
*
|
||||
* A. mantener el estado de libertad de todos los derivados de
|
||||
* nuestro software libre
|
||||
* B. promover el uso comunitario y compartido del software en
|
||||
* general
|
||||
*
|
||||
*
|
||||
*
|
||||
* <b>NO EXISTE GARANTIA ALGUNA</b>
|
||||
* -----------------------------------------------------------------
|
||||
*
|
||||
* 11. DEBIDO A QUE EL PROGRAMA SE OTORGA LIBRE DE CARGOS Y REGALIAS,
|
||||
* NO EXISTE NINGUNA GARANTIA PARA EL MISMO HASTA DONDE LO PERMITA
|
||||
* LA LEY APLICABLE. A EXCEPCION DE QUE SE INDIQUE OTRA COSA, LOS
|
||||
* PROPIETARIOS DE LOS DERECHOS DE AUTOR PROPORCIONAN EL PROGRAMA
|
||||
* "COMO ESTA" SIN NINGUNA GARANTIA DE NINGUN TIPO, YA SEA EXPLICITA
|
||||
* O IMPLICITA, INCLUYENDO, PERO NO LIMITADA A, LAS GARANTIAS QUE
|
||||
* IMPLICA EL MERCADEO Y EJERCICIO DE UN PROPOSITO EN PARTICULAR.
|
||||
* CUALQUIER RIESGO DEBIDO A LA CALIDAD Y DESEMPEÑO DEL PROGRAMA ES
|
||||
* TOMADO COMPLETAMENTE POR USTED. SI EL SOFTWARE MUESTRA ALGUN
|
||||
* DEFECTO, USTED CUBRIRA LOS COSTOS DE CUALQUIER SERVICIO,
|
||||
* REPARACION O CORRECCION DE SUS EQUIPOS Y/O SOFTWARE QUE REQUIERA.
|
||||
*
|
||||
* 12. EN NINGUN CASO NI BAJO NINGUNA CIRCUNSTANCIA EXCEPTO BAJO
|
||||
* SOLICITUD DE LA LEY O DE COMUN ACUERDO POR ESCRITO, NINGUN
|
||||
* PROPIETARIO DE LOS DERECHOS DE AUTOR NI TERCERAS PERSONAS QUE
|
||||
* PUDIERAN MODIFICAR Y/O REDISTRIBUIR EL PROGRAMA COMO SE PERMITE
|
||||
* ARRIBA, SERAN RESPONSABLES DE LOS DAÑOS CORRESPONDIENTES AL USO
|
||||
* O IMPOSIBILIDAD DE USAR EL PROGRAMA, SIN IMPORTAR SI SON DAÑOS
|
||||
* GENERALES, ESPECIALES, INCIDENTALES O CONSEQUENTES
|
||||
* CORRESPONDIENTES AL USO O IMPOSIBILIDAD DE USAR EL PROGRAMA
|
||||
* (INCLUYENDO PERO NO LIMITADO A LA PERDIDA DE INFORMACION O
|
||||
* DETERIORO DE LA MISMA AFECTANDOLO A USTED, A TERCERAS PERSONAS
|
||||
* QUE SEA POR FALLAS EN LA OPERACION DEL PROGRAMA O SU INTERACCION
|
||||
* CON OTROS PROGRAMAS) INCLUSIVE SI TAL PROPIETARIO U OTRAS
|
||||
* PERSONAS HAYAN SIDO NOTIFICADAS DE TALES FALLAS Y DE LA
|
||||
* POSIBILIDAD DE TALES DAÑOS.
|
||||
*
|
||||
*
|
||||
* <b>FIN DE TERMINOS Y CONDICIONES</b>
|
||||
*
|
||||
* -----------------------------------------------------------------
|
||||
*
|
||||
*
|
||||
* Apendice: C¢mo aplicar estos t‚rminos a sus nuevos programas ?
|
||||
*
|
||||
* Si usted desarrolla un nuevo Programa y desea que sea lo m s
|
||||
* p£blico posible, el mejor modo de hacerlo es haciendolo Software
|
||||
* Libre donde toda persona lo puede redistribuir y cambiar bajo
|
||||
* estos t‚rminos.
|
||||
*
|
||||
* Para hacer esto, agregue las siguientes notas al programa.
|
||||
* Es m s seguro agregarlas al inicio de cada archivo del c¢digo
|
||||
* fuente para notificar de manera m s efectiva la ausencia de
|
||||
* garant¡a; y cada archivo debe de contener al menos la l¡nea de
|
||||
* "Copyright" o derechos de autor y una referencia de donde se
|
||||
* puede encontrar la nota completa.
|
||||
* ejemplo:
|
||||
*
|
||||
* Una l¡nea que contenga el nombre del programa y una idea de lo
|
||||
* que hace.
|
||||
* Copyright (C) <a¤o> <nombre del autor>
|
||||
*
|
||||
* Este programa es Software Libre; usted puede redistribuirlo
|
||||
* y/o modificarlo bajo los t‚rminos de la "GNU General Public
|
||||
* License" como lo publica la "FSF Free Software Foundation",
|
||||
* ¢ (a su elecci¢n) de cualquier versi¢n posterior.
|
||||
*
|
||||
* Este programa es distribuido con la esperanza de que le ser
|
||||
* £til, pero SIN NINGUNA GARANTIA; incluso sin la garant¡a
|
||||
* impl¡cita por el MERCADEO o EJERCICIO DE ALGUN PROPOSITO en
|
||||
* particular. Vea la "GNU General Public License" para m s
|
||||
* detalles.
|
||||
*
|
||||
* Usted debe haber recibido una copia de la "GNU General Public
|
||||
* License" junto con este programa, si no, escriba a la "FSF
|
||||
* Free Software Foundation, Inc.", 59 Temple Place - Suite 330,
|
||||
* Boston, MA 02111-1307, USA.
|
||||
*
|
||||
* Adicionalmente agregue informaci¢n de c¢mo contactarle por
|
||||
* correo electr¢nico y convencional.
|
||||
* Si el programa es interactivo, ponga en la salida del programa
|
||||
* una nota corta al iniciar el modo interactivo como en siguiente
|
||||
* ejemplo:
|
||||
*
|
||||
* Gnomovision version 69, Copyright (C) <a¤o> <nombre del autor>
|
||||
* Gnomovision no tiene NINGUNA GARANTIA, para m s detalles
|
||||
* escriba 'show w'. Este es Software Libre, y usted est
|
||||
* permitido para redistribuirlo bajo ciertas condiciones;
|
||||
* escriba 'show c' para m s detalles.
|
||||
*
|
||||
* Estos hipoteticos comandos 'show w' y 'show c' deber n mostrar
|
||||
* las partes apropiadas de la "GPL General Public License".
|
||||
* Por supuesto, los comandos que utilice pueden ser distintos,
|
||||
* pueden ser incluso "clicks" del rat¢n, opciones de men£s etc, lo
|
||||
* m s apropiado para su programa.
|
||||
*
|
||||
* Usted deber¡a hacer que su jefe de proyecto (si trabaja como
|
||||
* programador) o su escuela, si aplica, firme una "declaraci¢n de
|
||||
* derechos de autor" para el programa, si se necesita.
|
||||
* Aqu¡ hay un ejemplo, modifique los nombres:
|
||||
*
|
||||
* "Yoyodyne, Inc., por este medio renuncia a todo inter‚s
|
||||
* en los derechos de autor en el programa 'Gnomovision'
|
||||
* (lo que make pasa al compilador) escrito por James Hacker."
|
||||
*
|
||||
* <firma de> Ty Coon, 1 de Abril 1989
|
||||
* Ty Coon, Presidente de Yoyodyne, Inc
|
||||
*
|
||||
*
|
||||
* Esta Licencia P£blica General no permite incorporar su programa
|
||||
* en programas propietarios. Si su programa es una librer¡a de
|
||||
* subrutinas, puede ser m s £til permitir que se ligue en tiempo de
|
||||
* compilaci¢n o ejecuci¢n a aplicaciones propietarias. Si esto es
|
||||
* lo que quiere hacer, use la licencia P£blica General para
|
||||
* Librer¡as en lugar de esta licencia.
|
||||
*
|
||||
* Consultas y dudas sobre FSF y GNU dirigirlas a gnu@gnu.org
|
||||
*
|
||||
* Free Software Foundation, Inc.,
|
||||
* 59 Temple Place - Suite 330, Boston, MA 02111, USA
|
||||
* Updated: 3 Jan 2000 rms
|
||||
*
|
||||
* $SEEALSO$
|
||||
* Licencia,Licencia GNU
|
||||
* $END$
|
||||
*/
|
||||
|
||||
|
||||
|
||||
445
harbour/doc/es/hvm.txt
Normal file
445
harbour/doc/es/hvm.txt
Normal file
@@ -0,0 +1,445 @@
|
||||
/*
|
||||
* $Id$
|
||||
*/
|
||||
|
||||
/*
|
||||
* Las siguientes partes son derechos adquiridos de sus autores individuales.
|
||||
* www - http://www.harbour-project.org
|
||||
*
|
||||
* Copyright 2000 Alejandro de G rate <alex_degarate@hotmail.com>
|
||||
* Documentaci¢n en Espa¤ol de:
|
||||
* PROCNAME(), PROCLINE(), PROCFILE(), HB_PVALUE(), PCOUNT()
|
||||
* __QUIT(), CLIPINIT(), __SetHelpK(), BREAK(), DO(), __VMVARLGET()
|
||||
*
|
||||
* Copyright 1999 Jose Lanin <dezac@corevia.com>
|
||||
* Documentaci¢n en Ingl‚s de: PROCLINE(),PROCFILE(),PROCNAME()
|
||||
*
|
||||
* Copyright 1999 Eddie Ruina
|
||||
* Documentaci¢n en Ingl‚s de: __VMVARLGET()
|
||||
*
|
||||
* Copyright 1999 Chen Kedem <niki@actcom.co.il>
|
||||
* Documentaci¢n en Ingl‚s de: CLIPINIT(), __SETHELPK()
|
||||
*
|
||||
* Copyright 1999 Ryszard Glab <rglab@imid.med.pl>
|
||||
* Documentaci¢n en Ingl‚s de: DO()
|
||||
*
|
||||
* Vea doc/license.txt por los t‚rminos de la licencia.
|
||||
*
|
||||
*/
|
||||
|
||||
/* $DOC$
|
||||
* $FUNCNAME$
|
||||
* PROCNAME()
|
||||
* $CATEGORY$
|
||||
* Miscelanea
|
||||
* $ONELINER$
|
||||
* Obtiene el nombre de la funci¢n actual en la pila
|
||||
* $SYNTAX$
|
||||
* PROCNAME( <nLevel> ) --> <cProcName>
|
||||
* $ARGUMENTS$
|
||||
* <nLevel> es el nivel de la funci¢n requerida
|
||||
* $RETURNS$
|
||||
* <cProcName> El nombre de la funci¢n que esta siendo ejecutada
|
||||
* $DESCRIPTION$
|
||||
* Esta funci¢n mira al tope de la pila y obtiene el nombre de la
|
||||
* funci¢n actual ejecutada si no se pasaron argumentos. De otra
|
||||
* manera esta retorna el nombre de la funci¢n ¢ procedimiento en el
|
||||
* nivel <nLevel>.
|
||||
* $EXAMPLES$
|
||||
* Ver Test
|
||||
* </fixed>
|
||||
* $TESTS$
|
||||
* Este test mostrar las funciones y procedimientos en la pila
|
||||
* antes de ejecutarlas.
|
||||
*
|
||||
* FUNCTION Test()
|
||||
* LOCAL n := 1
|
||||
* while !Empty( ProcName( n ) )
|
||||
* ? ProcName( n++ )
|
||||
* end do
|
||||
* RETURN NIL
|
||||
* </fixed>
|
||||
* $STATUS$
|
||||
* R
|
||||
* $COMPLIANCE$
|
||||
* PROCNAME() es totalmente compatible con CA-Clipper.
|
||||
* $PLATFORMS$
|
||||
* Todas.
|
||||
* $FILES$
|
||||
* La librer¡a asociada es vm
|
||||
* $SEEALSO$
|
||||
* PROCLINE(),PROCFILE()
|
||||
* $END$
|
||||
*/
|
||||
|
||||
/* $DOC$
|
||||
* $FUNCNAME$
|
||||
* PROCLINE()
|
||||
* $CATEGORY$
|
||||
* Miscelanea
|
||||
* $ONELINER$
|
||||
* Obtiene el n£mero de l¡nea de la funci¢n actual en la pila
|
||||
* $SYNTAX$
|
||||
* PROCLINE( <nLevel> ) --> <nLinea>
|
||||
* $ARGUMENTS$
|
||||
* <nLevel> es el nivel de funci¢n requerida
|
||||
* $RETURNS$
|
||||
* <nLinea> el n£mero de l¡nea de la funci¢n que esta siendo ejecutada
|
||||
* $DESCRIPTION$
|
||||
* Esta funci¢n mira al tope de la pila y obtiene el n£mero de l¡nea
|
||||
* de la funci¢n actual ejecutada si no se pasaron argumentos. De otra
|
||||
* manera esta retorna el n£mero de l¡nea de la funci¢n ¢ procedimiento
|
||||
* en el nivel <nLevel>.
|
||||
* $EXAMPLES$
|
||||
* Ver Test
|
||||
* </fixed>
|
||||
* $TESTS$
|
||||
* FUNCTION Test()
|
||||
* ? ProcLine( 0 )
|
||||
* ? ProcName( 2 )
|
||||
* RETURN NIL
|
||||
* </fixed>
|
||||
* $STATUS$
|
||||
* R
|
||||
* $COMPLIANCE$
|
||||
* PROCLINE() es totalmente compatible con CA-Clipper.
|
||||
* $PLATFORMS$
|
||||
* Todas.
|
||||
* $FILES$
|
||||
* La librer¡a asociada es vm
|
||||
* $SEEALSO$
|
||||
* PROCNAME(),PROCFILE()
|
||||
* $END$
|
||||
*/
|
||||
|
||||
/* $DOC$
|
||||
* $FUNCNAME$
|
||||
* PROCFILE()
|
||||
* $CATEGORY$
|
||||
* Miscelanea
|
||||
* $ONELINER$
|
||||
* Esta funci¢n siempre retorna una cadena vac¡a.
|
||||
* $SYNTAX$
|
||||
* PROCFILE( <xExp> ) --> <cEmptyString>
|
||||
* $ARGUMENTS$
|
||||
* <xExp> es cualquier tipo v lido
|
||||
* $RETURNS$
|
||||
* Retorna la cadena vac¡a <cEmptyString>.
|
||||
* $DESCRIPTION$
|
||||
* Esta funci¢n es agregada a la RTL por total compatibilidad.
|
||||
* Esta siempre retorna una cadena vac¡a.
|
||||
* $EXAMPLES$
|
||||
* ? ProcFile()
|
||||
* </fixed>
|
||||
* $TESTS$
|
||||
* FUNCTION Test()
|
||||
* ? ProcFile()
|
||||
* ? ProcFile( NIL )
|
||||
* ? ProcFile( 2 )
|
||||
* RETURN NIL
|
||||
* </fixed>
|
||||
* $STATUS$
|
||||
* R
|
||||
* $COMPLIANCE$
|
||||
* PROCFILE() es totalmente compatible con CA-Clipper.
|
||||
* $PLATFORMS$
|
||||
* Todas.
|
||||
* $FILES$
|
||||
* La librer¡a asociada es vm
|
||||
* $SEEALSO$
|
||||
* PROCNAME(),PROCLINE()
|
||||
* $END$
|
||||
*/
|
||||
|
||||
/* $DOC$
|
||||
* $FUNCNAME$
|
||||
* HB_PVALUE()
|
||||
* $CATEGORY$
|
||||
* Chequeo Parametros
|
||||
* $ONELINER$
|
||||
* Obtiene el valor de un argumento.
|
||||
* $SYNTAX$
|
||||
* HB_PVALUE( <nArg> ) --> <xExp>
|
||||
* $ARGUMENTS$
|
||||
* Un n£mero que indica el argumento a chequear.
|
||||
* $RETURNS$
|
||||
* <xExp> Retorna el valor almacenado en el argumento.
|
||||
* $DESCRIPTION$
|
||||
* Esta funci¢n es £til para chequear el valor almacenado en un
|
||||
* argumento.
|
||||
* $EXAMPLES$
|
||||
* Ver Test
|
||||
* </fixed>
|
||||
* $TESTS$
|
||||
* FUNCTION Test( nValue, cString )
|
||||
* IF PCount() == 2
|
||||
* ? hb_PValue( 1 ), nValue
|
||||
* ? hb_PValue( 2 ), cString
|
||||
* ENDIF
|
||||
* RETURN NIL
|
||||
* </fixed>
|
||||
* $STATUS$
|
||||
* R
|
||||
* $COMPLIANCE$
|
||||
* HB_PVALUE() es una nueva funci¢n y por tanto no es compatible con
|
||||
* CA-Clipper.
|
||||
* $PLATFORMS$
|
||||
* Todas.
|
||||
* $FILES$
|
||||
* La librer¡a asociada es vm
|
||||
* $SEEALSO$
|
||||
* PCOUNT()
|
||||
* $END$
|
||||
*/
|
||||
|
||||
/* $DOC$
|
||||
* $FUNCNAME$
|
||||
* PCOUNT()
|
||||
* $CATEGORY$
|
||||
* Chequeo Parametros
|
||||
* $ONELINER$
|
||||
* Obtiene el n£mero de argumentos pasados a la funci¢n.
|
||||
* $SYNTAX$
|
||||
* PCOUNT() --> <nArgs>
|
||||
* $ARGUMENTS$
|
||||
* Ninguno.
|
||||
* $RETURNS$
|
||||
* <nArgs> Un n£mero que indica la cantidad de par metros pasados a
|
||||
* la funci¢n ¢ procedimiento,
|
||||
* $DESCRIPTION$
|
||||
* Esta funci¢n es £til para chequear si una funci¢n ¢ procedimiento a
|
||||
* recibido el n£mero de argumentos necesario.
|
||||
* $EXAMPLES$
|
||||
* Ver Test
|
||||
* </fixed>
|
||||
* $TESTS$
|
||||
* FUNCTION Test( xExp )
|
||||
* IF PCount() == 0
|
||||
* ? "Esta funci¢n necesita un par metro"
|
||||
* ELSE
|
||||
* ? xExp
|
||||
* ENDIF
|
||||
* RETURN NIL
|
||||
* </fixed>
|
||||
* $STATUS$
|
||||
* R
|
||||
* $COMPLIANCE$
|
||||
* PCOUNT() es totalmente compatible con CA-Clipper.
|
||||
* $PLATFORMS$
|
||||
* Todas.
|
||||
* $FILES$
|
||||
* La librer¡a asociada es vm
|
||||
* $SEEALSO$
|
||||
* HB_PVALUE()
|
||||
* $END$
|
||||
*/
|
||||
|
||||
/* $DOC$
|
||||
* $FUNCNAME$
|
||||
* __QUIT()
|
||||
* $CATEGORY$
|
||||
* Eventos
|
||||
* $ONELINER$
|
||||
* Termina una aplicaci¢n.
|
||||
* $SYNTAX$
|
||||
* __QUIT() --> NIL
|
||||
* $ARGUMENTS$
|
||||
* Ninguno
|
||||
* $RETURNS$
|
||||
* NIL
|
||||
* $DESCRIPTION$
|
||||
* Esta funci¢n termina la aplicaci¢n actual y retorna al sistema.
|
||||
* $EXAMPLES$
|
||||
* Ver Test
|
||||
* </fixed>
|
||||
* $TESTS$
|
||||
* FUNCTION EndApp( lYesNo )
|
||||
* IF lYesNo
|
||||
* __Quit()
|
||||
* ENDIF
|
||||
* RETURN NIL
|
||||
* </fixed>
|
||||
* $STATUS$
|
||||
* R
|
||||
* $COMPLIANCE$
|
||||
* __QUIT() es totalmente compatible con CA-Clipper.
|
||||
* $PLATFORMS$
|
||||
* Todas.
|
||||
* $FILES$
|
||||
* La librer¡a asociada es vm
|
||||
* $SEEALSO$
|
||||
* QUIT
|
||||
* $END$
|
||||
*/
|
||||
|
||||
/* $DOC$
|
||||
* $FUNCNAME$
|
||||
* CLIPINIT()
|
||||
* $CATEGORY$
|
||||
* Internal
|
||||
* $ONELINER$
|
||||
* Initializa varios subsistemas de Harbour
|
||||
* $SYNTAX$
|
||||
* CLIPINIT() --> NIL
|
||||
* $ARGUMENTS$
|
||||
* Ninguno
|
||||
* $RETURNS$
|
||||
* CLIPINIT() siempre devuelve NIL.
|
||||
* $DESCRIPTION$
|
||||
* CLIPINIT() es uno de los INIT PROCEDURE predefinidos y es ejecutado
|
||||
* cuando el programa arranca. Este declara un array MEMVAR PUBLIC vac¡o
|
||||
* llamado GetList que va a ser usado por el sistema Get.
|
||||
* Este activa el manejador de error por defecto, y (al menos por el
|
||||
* momento) llama a la funci¢n que establece la tecla de Ayuda por
|
||||
* defecto (F1).
|
||||
* $STATUS$
|
||||
* R
|
||||
* $COMPLIANCE$
|
||||
* Se dice que CLIPINIT() no deber¡a llamar a la funci¢n que establece
|
||||
* la tecla de Ayuda por defecto (F1) dado que CA-Clipper lo hace en
|
||||
* otro lugar.
|
||||
* $PLATFORMS$
|
||||
* Todas.
|
||||
* $SEEALSO$
|
||||
* INIT PROCEDURE
|
||||
* $END$
|
||||
*/
|
||||
|
||||
/* $DOC$
|
||||
* $FUNCNAME$
|
||||
* __SetHelpK()
|
||||
* $CATEGORY$
|
||||
* Internal
|
||||
* $ONELINER$
|
||||
* Establece a <F1> como la tecla de Ayuda por defecto
|
||||
* $SYNTAX$
|
||||
* __SetHelpK() --> NIL
|
||||
* $ARGUMENTS$
|
||||
* Ninguno
|
||||
* $RETURNS$
|
||||
* __SetHelpK() siempre devuelve NIL
|
||||
* $DESCRIPTION$
|
||||
* Establece que al pulsar la tecla <F1>, se ejecute una funci¢n llamada
|
||||
* HELP si tal funci¢n es enlazada dentro del programa.
|
||||
* $STATUS$
|
||||
* R
|
||||
* $COMPLIANCE$
|
||||
* __SetHelpK() trabaja exactamente como la funci¢n de CA-Clipper
|
||||
* llamada __SetHelpK()
|
||||
* $PLATFORMS$
|
||||
* Todas.
|
||||
* $FILES$
|
||||
* La librer¡a asociada es vm
|
||||
* $SEEALSO$
|
||||
* __XHelp(),SET KEY,SETKEY()
|
||||
* $END$
|
||||
*/
|
||||
|
||||
/* $DOC$
|
||||
* $FUNCNAME$
|
||||
* BREAK()
|
||||
* $CATEGORY$
|
||||
* Error recovery
|
||||
* $ONELINER$
|
||||
* Sale de un bloque BEGIN SEQUENCE
|
||||
* $SYNTAX$
|
||||
* BREAK( <xExp> ) --> NIL
|
||||
* $ARGUMENTS$
|
||||
* <xExp> es cualquier expresi¢n v lida. Esta es requerida siempre
|
||||
* Si Ud. no desea pasarle ning£n argumento, s¢lo use NIL.
|
||||
* $RETURNS$
|
||||
* NIL
|
||||
* $DESCRIPTION$
|
||||
* Esta funci¢n le pasa el control a la sentencia RECOVER en un bloque
|
||||
* BEGIN SEQUENCE.
|
||||
* $EXAMPLES$
|
||||
* Break( NIL )
|
||||
* </fixed>
|
||||
* $STATUS$
|
||||
* R
|
||||
* $COMPLIANCE$
|
||||
* BREAK() es totalmente compatible con CA-Clipper.
|
||||
* $PLATFORMS$
|
||||
* Todas.
|
||||
* $FILES$
|
||||
* La librer¡a asociada es vm
|
||||
* $SEEALSO$
|
||||
* BEGIN SEQUENCE
|
||||
* $END$
|
||||
*/
|
||||
|
||||
/* $DOC$
|
||||
* $FUNCNAME$
|
||||
* DO()
|
||||
* $CATEGORY$
|
||||
* Utility
|
||||
* $ONELINER$
|
||||
* Llama a un procedimiento ¢ a una funci¢n
|
||||
* $SYNTAX$
|
||||
* DO( <xFuncProc> [, <xArguments...>] )
|
||||
* $ARGUMENTS$
|
||||
* <xFuncProc> es tanto una cadena con un nombre de funci¢n ¢
|
||||
* procedimiento a ser llamado, ¢ un codeblock a evaluar.
|
||||
* <xArguments> argumentos pasados a la funci¢n ¢ procedimiento
|
||||
* llamado ¢ a un codeblock.
|
||||
* $RETURNS$
|
||||
* A value that was returned from called function.
|
||||
* $DESCRIPTION$
|
||||
* Esta funci¢n puede ser llamada ¢ bien por el compilador Harbour ¢
|
||||
* por el usuario.
|
||||
* El compilador siempre siempre pasa el item de tipo IT_SYMBOL que
|
||||
* almacena el nombre del procedimiento especificado en la sentencia
|
||||
* DO <proc> WITH .
|
||||
* Si el procedimiento/funci¢n no existe, entonces un error de tiempo
|
||||
* de ejecuci¢n es generado.
|
||||
* Esta funci¢n puede ser usada como reemplazo del operador macro.
|
||||
* Esta es tambi‚n usada internamente para implementar:
|
||||
* DO <proc> WITH <args...>
|
||||
* En este caso <xFuncProc> es del tipo HB_SYMB.
|
||||
* $EXAMPLES$
|
||||
* cbCode ={|x| MyFunc( x )}
|
||||
* DO( cbCode, 1 )
|
||||
*
|
||||
* cFunction := "MyFunc"
|
||||
* xRetVal :=DO( cFunction, 2 )
|
||||
*
|
||||
* Old style (slower):
|
||||
* DO &cFunction WITH 3
|
||||
* </fixed>
|
||||
* $PLATFORMS$
|
||||
* Todas.
|
||||
* $FILES$
|
||||
* La librer¡a es rtl
|
||||
* $SEEALSO$
|
||||
*
|
||||
* $END$
|
||||
*/
|
||||
|
||||
/* $DOC$
|
||||
* $FUNCNAME$
|
||||
* __VMVARLGET()
|
||||
* $CATEGORY$
|
||||
* Variable Management
|
||||
* $ONELINER$
|
||||
* Obtiene una variable LOCAL de un nivel de procedimiento
|
||||
* $SYNTAX$
|
||||
* __VMVARLGET( <nProcLevel>, <nLocal> )
|
||||
* $ARGUMENTS$
|
||||
* <nProcLevel> Es el nivel de procedimiento, el mismo que el usado
|
||||
* en PROCNAME() y PROCLINE(), desde el cual una variable
|
||||
* local va a ser obtenida.
|
||||
* <nLocal> Es la posici¢n ¢ ¡ndice de la variable local a recuperar
|
||||
* $RETURNS$
|
||||
* El contenido de la variable local especificada.
|
||||
* $DESCRIPTION$
|
||||
* Esta funci¢n es usada desde el depurador.
|
||||
* $PLATFORMS$
|
||||
* Todas.
|
||||
* $FILES$
|
||||
* La librer¡a asociada es vm
|
||||
* $SEEALSO$
|
||||
* PROCNAME()
|
||||
* $END$
|
||||
*/
|
||||
|
||||
|
||||
484
harbour/doc/es/input.txt
Normal file
484
harbour/doc/es/input.txt
Normal file
@@ -0,0 +1,484 @@
|
||||
|
||||
/*
|
||||
* Las siguientes partes son derechos adquiridos de sus autores individuales.
|
||||
* www - http://www.harbour-project.org
|
||||
*
|
||||
* Copyright 2000 Alejandro de G rate <alex_degarate@hotmail.com>
|
||||
* Documentaci¢n en Espa¤ol de:
|
||||
* INKEY(), __KEYBOARD(), HB_KEYPUT(), NEXTKEY()
|
||||
* LASTKEY(), KEYBOARD, READKEY(), MROW(), MCOL()
|
||||
* Copyright 1999 Chen Kedem <niki@actcom.co.il>
|
||||
* Documentation for: READKEY()
|
||||
*
|
||||
* Vea doc/license.txt por los t‚rminos de la licencia.
|
||||
*
|
||||
*/
|
||||
|
||||
/* $DOC$
|
||||
* $FUNCNAME$
|
||||
* INKEY()
|
||||
* $CATEGORY$
|
||||
* Entrada de Consola
|
||||
* $ONELINER$
|
||||
* Extrae el pr¢ximo c¢digo de tecla desde el buffer de teclado.
|
||||
* $SYNTAX$
|
||||
* INKEY( [<nTiempoEspera>] [,<nEventos>] ) --> nTecla
|
||||
* $ARGUMENTS$
|
||||
* <nTiempoEspera> es un valor opcional de tiempo de espera en segundos,
|
||||
* con una resoluci¢n de 1/10th de segundo.
|
||||
* Si es omitido, INKEY() retorna inmediatamente.
|
||||
* Si es cero, INKEY() espera hasta que un evento de entrada suceda.
|
||||
* Si es establecido en cualquier otro valor INKEY() retornara tanto
|
||||
* cuando un evento de entrada ocurra como cuando el per¡odo de espera
|
||||
* haya transcurrido.
|
||||
* Si s¢lo este par metro es especificado y este no es num‚rico, ‚ste
|
||||
* ser tratado como si fuera cero. Pero si ambos par metros son
|
||||
* especificados y este par metro no es num‚rico, este ser tratado
|
||||
* como si no estuviese presente.
|
||||
*
|
||||
* <nEventos> es una m scara opcional de los eventos de entrada que son
|
||||
* habilitados.
|
||||
* Si es omitida por defecto es hb_set.HB_SET_EVENTMASK.
|
||||
* M scaras v lidas de entrada se ecuentran en inkey.ch y son explicadas
|
||||
* m s abajo. Se recomienda usar los nombres de estas m scaras, antes
|
||||
* que sus valores num‚ricos, en el caso que estos valores num‚ricos
|
||||
* cambien en futuras versiones de Harbour.
|
||||
* Para permitir m s de un tipo de evento de entrada, simplemente sume
|
||||
* varios nombres de m scara todos juntos.
|
||||
*
|
||||
* <table>
|
||||
* inkey.ch Significado de los eventos
|
||||
*
|
||||
* INKEY_MOVE permitidos los eventos de movimiento del mouse
|
||||
* INKEY_LDOWN permitido apretar el bot¢n izq. del mouse
|
||||
* INKEY_LUP permitido soltar el bot¢n izquierdo del mouse
|
||||
* INKEY_RDOWN permitido apretar el bot¢n derecho del mouse
|
||||
* INKEY_RUP permitido soltar el bot¢n derecho del mouse
|
||||
* INKEY_KEYBOARD Todos los eventos de teclado estan permitidos
|
||||
* INKEY_ALL Todos los eventos de mouse y teclado estan
|
||||
* permitidos
|
||||
* HB_INKEY_EXTENDED Codigos Extendidos de teclado son usados
|
||||
* </table>
|
||||
* Si el par metro no es num‚rico, este ser tratado como si hubiese
|
||||
* sido establecido a hb_set.HB_SET_EVENTMASK.
|
||||
* $RETURNS$
|
||||
* INKEY() retorna cero en caso de transcurrido el tiempo de espera sin
|
||||
* ning£n evento de entrada, de otro modo retorna un valor en el rango
|
||||
* -39 a 386 para eventos de teclado ¢ en le rango de 1001 a 1007 para
|
||||
* eventos de mouse.
|
||||
* Los eventos de mouse y los eventos de teclado que no se pueden
|
||||
* imprimir son representados por los valores K_<evento> listados en
|
||||
* el archivo inkey.ch
|
||||
* Los c¢digo de teclas de los eventos de teclado en el rango de 32 a
|
||||
* 127 son los equivalentes al set de caracteres ASCII. Los c¢digos de
|
||||
* retorno de eventos de teclado en el rango de 128 a 255 son asumidos
|
||||
* como imprimibles, pero los resultados pueden variar basados en el
|
||||
* hardware del teclado y la nacionalidad de su seteo.
|
||||
*
|
||||
* Los codigos de tecla Extendidos para un teclado de PC consisten de
|
||||
* scancode y uno o mas valores de desplazamiento (offset).
|
||||
* Si ningun modificador de teclado fue usado entonces HB_INKEY_NONE
|
||||
* es agregado. Las teclas <Alt> agregan HB_INKEY_ALT, las teclas
|
||||
* <Ctrl> agregan HB_INKEY_CTRL, las teclas de desplazamiento (Shift),
|
||||
* (que se simbolizan con una flecha hacia arriba) agregan
|
||||
* HB_INKEY_SHIFT, y las teclas adicionales del teclado numerico
|
||||
* ubicadas a la derecha
|
||||
* del teclado (teclas KeyPad y CursorPad ) agregan HB_INKEY_ENHANCED.
|
||||
*
|
||||
* Por ejemplo la tecla <F1> tiene un scancode de 59, asi que si solo
|
||||
* se pulsa <F1> se obtiene el codigo 315, <Alt+F1> da 443, <Ctrl+F1>
|
||||
* da 571, <Shift+F1> da 699. <>
|
||||
*
|
||||
* ?????? And NumPad+/ gives 1077, 1205, 1333, and 1461. At
|
||||
* this time, the only value that can combine with other values is
|
||||
* HB_INKEY_ENHANCED (i.e., there are no Alt+Ctl combinations, etc.)
|
||||
*
|
||||
* Nota: El conjunto de codigos de teclas extendido es mayor que el
|
||||
* conjunto de codigo de tecla normal. Como resultante de esto, si
|
||||
* Ud. cambia entre los modos normal y extendido, Ud. debe saber que
|
||||
* algunos codigos son trasladados como cero en el modo normal (esto
|
||||
* es debido a que existe el correspondiente codigo para esa tecla en
|
||||
* modo normal) y que esos codigos seran removidos del buffer de
|
||||
* entrada del teclado en el modo normal y que Ud. no podr volver
|
||||
* atras y obtenerlos luego en modo extendido.
|
||||
* $DESCRIPTION$
|
||||
* INKEY() puede ser usada para detectar eventos de entrada, como la
|
||||
* pulsaci¢n de una tecla, ¢ un click del mouse (arriba y/o abajo).
|
||||
* $EXAMPLES$
|
||||
* // Espera a que el usuario presione la tecla Esc
|
||||
* ? "Por favor, presione la tecla ESC."
|
||||
* WHILE INKEY( 0.1 ) != K_ESC
|
||||
* END
|
||||
* </fixed>
|
||||
* $TESTS$
|
||||
* KEYBOARD "AB"; ? INKEY(), INKEY() ==> 65 66
|
||||
* </fixed>
|
||||
* $STATUS$
|
||||
* S
|
||||
* $COMPLIANCE$
|
||||
* INKEY() es compatible con la funci¢n INKEY() de Clipper 5.3 con una
|
||||
* excepci¢n: La funci¢n INKEY() de Harbour dar un error de argumento
|
||||
* si el primer par metro es menor ¢ igual a cero y el segundo par metro
|
||||
* ( ¢ la m scara por defecto ) no es v lida, porque de otra manera
|
||||
* INKEY() podr¡a no retornar nunca, porque en efecto espera por
|
||||
* siempre por un un evento que no se va a producir (Nota: En Clipper,
|
||||
* esto tambi‚n bloquea los eventos SET KEY).
|
||||
* $FILES$
|
||||
* La librer¡a es rtl
|
||||
* $SEEALSO$
|
||||
* inkey.ch
|
||||
* $END$
|
||||
*/
|
||||
|
||||
|
||||
/* $DOC$
|
||||
* $FUNCNAME$
|
||||
* __KEYBOARD()
|
||||
* $CATEGORY$
|
||||
* Entrada de Consola
|
||||
* $ONELINER$
|
||||
* NO LLAMAR A ESTA FUNCION DIRECTAMENTE !
|
||||
* $SYNTAX$
|
||||
* KEYBOARD <cString>
|
||||
* CLEAR TYPEAHEAD
|
||||
* $ARGUMENTS$
|
||||
* <cString> es una cadena opcional para ser colocada en el buffer
|
||||
* de teclado de Harbour despu‚s de borrarlo.
|
||||
* Nota: El car cter ";" es convertido a CHR(13) (esta es
|
||||
* una caracter¡stica no documentada de CA-Clipper).
|
||||
* $RETURNS$
|
||||
* No hay valor de retorno.
|
||||
* $DESCRIPTION$
|
||||
* Borra el buffer de teclado de Harbour y luego inserta una cadena
|
||||
* opcional en ‚ste.
|
||||
* $EXAMPLES$
|
||||
* // Pone la tecla <enter> en el buffer de teclado
|
||||
* KEYBOARD CHR(13)
|
||||
*
|
||||
* // Borra el buffer de teclado
|
||||
* CLEAR TYPEAHEAD
|
||||
* </fixed>
|
||||
* $TESTS$
|
||||
* KEYBOARD CHR(13); ? INKEY() ==> 13
|
||||
* KEYBOARD ";" ? INKEY() ==> 13
|
||||
* KEYBOARD "HOLA"; CLEAR TYPEAHEAD; ? INKEY() ==> 0
|
||||
* </fixed>
|
||||
* $STATUS$
|
||||
* R
|
||||
* $COMPLIANCE$
|
||||
* __KEYBOARD() es compatible con CA-Clipper 5.3
|
||||
* $FILES$
|
||||
* La librer¡a es rtl
|
||||
* $SEEALSO$
|
||||
* CLEAR TYPEAHEAD,KEYBOARD
|
||||
* $END$
|
||||
*/
|
||||
|
||||
|
||||
/* $DOC$
|
||||
* $FUNCNAME$
|
||||
* HB_KEYPUT()
|
||||
* $CATEGORY$
|
||||
* Entrada de Consola
|
||||
* $ONELINER$
|
||||
* Pone un c¢digo de tecla en el buffer de teclado.
|
||||
* $SYNTAX$
|
||||
* HB_KEYPUT( <nInkeyCode> )
|
||||
* $ARGUMENTS$
|
||||
* <nInkeyCode> es el c¢digo de tecla. que deber¡a ser insertado en
|
||||
* el buffer de teclado.
|
||||
* $RETURNS$
|
||||
* No hay valor de retorno.
|
||||
* $DESCRIPTION$
|
||||
* Inserta un c¢digo de tecla en el buffer de teclado.
|
||||
* El buffer *NO* es borrado en esta operaci¢n. Esta funci¢n permite
|
||||
* insertar c¢digos de teclas que no estan en el rango de 0 a 255.
|
||||
* Para insertar m s de un c¢digo, llame a la funci¢n repetidamente.
|
||||
* El c¢digo cero no puede ser insertado.
|
||||
* $EXAMPLES$
|
||||
* // Coloca la tecla de Alt+PgDn key en el buffer de teclado.
|
||||
* HB_KEYPUT( K_ALT_PGDN )
|
||||
* </fixed>
|
||||
* $TESTS$
|
||||
* HB_KEYPUT( K_ALT_PGDN ) ; ? INKEY() ==> 417
|
||||
* HB_KEYPUT( K_F11 ) ; ? INKEY() ==> -40
|
||||
* </fixed>
|
||||
* $STATUS$
|
||||
* R
|
||||
* $COMPLIANCE$
|
||||
* HB_KEYPUT() es una extensi¢n de Harbour.
|
||||
* $FILES$
|
||||
* La librer¡a es rtl
|
||||
* $SEEALSO$
|
||||
* KEYBOARD,CLEAR TYPEAHEAD,INKEY()
|
||||
* $END$
|
||||
*/
|
||||
|
||||
/* $DOC$
|
||||
* $FUNCNAME$
|
||||
* NEXTKEY()
|
||||
* $CATEGORY$
|
||||
* Entrada de Consola
|
||||
* $ONELINER$
|
||||
* Lee la pr¢xima tecla del buffer de teclado sin extraerla
|
||||
* $SYNTAX$
|
||||
* NEXTKEY( [<nInputMask>] ) --> nTecla
|
||||
* $ARGUMENTS$
|
||||
* <nInputMask> es un valor entero opcional compuesto por una o mas
|
||||
* constantes INKEY_ or HB_INKEY_
|
||||
* El solo proposito de este argumento es permitir cambiar
|
||||
* entre los codigos de tecla HB_INKEY_EXTENDED y usar
|
||||
* los codigos de tecla normales compatibles con Clipper.
|
||||
* $RETURNS$
|
||||
* <nTecla> el valor del pr¢ximo c¢digo de tecla del buffer de teclado.
|
||||
* $DESCRIPTION$
|
||||
* Retorna el valor del pr¢ximo c¢digo de tecla del buffer de teclado
|
||||
* sin extraerlo.
|
||||
* $EXAMPLES$
|
||||
* // Uso de NEXTKEY() con INKEY() para cambiar los caracteres a mostrar
|
||||
* // ¢ para poder salir del bucle, as¡ el llamador puede detectar
|
||||
* // la tecla ESC.
|
||||
* LOCAL nTecla, cChar := "+"
|
||||
*
|
||||
* WHILE TRUE
|
||||
* ?? cChar
|
||||
* nTecla := NEXTKEY()
|
||||
*
|
||||
* IF nTecla == K_ESC
|
||||
* EXIT
|
||||
* ELSE
|
||||
* IF nTecla != 0
|
||||
* cChar := CHR( nTecla )
|
||||
* END IF
|
||||
* ENDIF
|
||||
*
|
||||
* END WHILE
|
||||
* </fixed>
|
||||
* $TESTS$
|
||||
* KEYBOARD "AB"; ? NEXTKEY(), NEXTKEY() ==> 65 65
|
||||
* </fixed>
|
||||
* $STATUS$
|
||||
* R
|
||||
* $COMPLIANCE$
|
||||
* NEXTKEY() es compatible con CA-Clipper 5.3
|
||||
* $FILES$
|
||||
* La librer¡a es rtl
|
||||
* $SEEALSO$
|
||||
* INKEY(),LASTKEY()
|
||||
* $END$
|
||||
*/
|
||||
|
||||
/* $DOC$
|
||||
* $FUNCNAME$
|
||||
* LASTKEY()
|
||||
* $CATEGORY$
|
||||
* Entrada de Consola
|
||||
* $ONELINER$
|
||||
* Obtiene el £ltima tecla extraida desde el buffer de teclado.
|
||||
* $SYNTAX$
|
||||
* LASTKEY( [<nInputMask>] ) --> nTecla
|
||||
* $ARGUMENTS$
|
||||
* <nInputMask> es un valor entero opcional compuesto por una o mas
|
||||
* constantes INKEY_ o HB_INKEY_
|
||||
* El solo proposito de este argumento es permitir cambiar
|
||||
* entre los codigos de tecla HB_INKEY_EXTENDED y usar
|
||||
* los codigos de tecla normales compatibles con Clipper.
|
||||
* $RETURNS$
|
||||
* <nTecla> la £ltima tecla extraida desde el buffer de teclado.
|
||||
* $DESCRIPTION$
|
||||
* LASTKEY() retorna el valor de la £ltima tecla extraida del buffer
|
||||
* de teclado.
|
||||
* $EXAMPLES$
|
||||
* // Continua el bucle a menos que la tecla ESC haya sido presionada
|
||||
* // en MainFunc()
|
||||
* WHILE TRUE
|
||||
*
|
||||
* MainFunc()
|
||||
* IF LASTKEY() == K_ESC
|
||||
* EXIT
|
||||
* ENDIF
|
||||
*
|
||||
* END WHILE
|
||||
* </fixed>
|
||||
* $TESTS$
|
||||
* KEYBOARD "AB"; ? INKEY(), LASTKEY() ==> 65 65
|
||||
* </fixed>
|
||||
* $STATUS$
|
||||
* R
|
||||
* $COMPLIANCE$
|
||||
* LASTKEY() es compatible con CA-Clipper 5.3
|
||||
* $FILES$
|
||||
* La librer¡a es rtl
|
||||
* $SEEALSO$
|
||||
* INKEY(),LASTKEY()
|
||||
* $END$
|
||||
*/
|
||||
|
||||
/* $DOC$
|
||||
* $FUNCNAME$
|
||||
* KEYBOARD
|
||||
* $CATEGORY$
|
||||
* Comando
|
||||
* $ONELINER$
|
||||
* Rellena el buffer de teclado con una cadena.
|
||||
* $SYNTAX$
|
||||
* KEYBOARD <cString>
|
||||
* $ARGUMENTS$
|
||||
* <cString> es la cadena a ser procesada, un caracter a la vez, por
|
||||
* el procesador de teclado de Harbour.
|
||||
* $DESCRIPTION$
|
||||
* Este comando llena el buffer de entrada con <cString>.
|
||||
* El n£mero de caracteres que pueden ser puestos en el buffer de
|
||||
* teclado es controlado por el comando SET TYPEAHEAD y puede estar en
|
||||
* el rango de 0 a 32622, donde cada caracter corresponde al rango ASCII
|
||||
* de 0 a 255. Ninguna de las teclas extendidas puede ser puestas en
|
||||
* el buffer de teclado.
|
||||
* Haciendo KEYBOARD " " limpiar el buffer de teclado.
|
||||
* $EXAMPLES$
|
||||
* // Coloca la tecla <Enter> en el buffer de teclado.
|
||||
* KEYBOARD CHR(13)
|
||||
*
|
||||
* // Borra el buffer de teclado.
|
||||
* CLEAR TYPEAHEAD
|
||||
* </fixed>
|
||||
* $TESTS$
|
||||
* KEYBOARD CHR(13); ? INKEY() ==> 13
|
||||
* KEYBOARD "HOLA"; CLEAR TYPEAHEAD; ? INKEY() ==> 0
|
||||
* </fixed>
|
||||
* $STATUS$
|
||||
* R
|
||||
* $COMPLIANCE$
|
||||
* __KEYBOARD() es compatible con CA-Clipper 5.3
|
||||
* $SEEALSO$
|
||||
* CLEAR TYPEAHEAD,__KEYBOARD()
|
||||
* $END$
|
||||
*/
|
||||
|
||||
/* $DOC$
|
||||
* $FUNCNAME$
|
||||
* READKEY()*
|
||||
* $CATEGORY$
|
||||
* Entrada y Salida de datos
|
||||
* $ONELINER$
|
||||
* Encuentra cual tecla caus¢ la salida del READ
|
||||
* $SYNTAX$
|
||||
* READKEY() --> nCodigoTecla
|
||||
* $ARGUMENTS$
|
||||
* Ninguno.
|
||||
* $RETURNS$
|
||||
* READKEY() retorna un c¢digo num‚rico representando la tecla que
|
||||
* caus¢ la terminaci¢n del READ.
|
||||
* $DESCRIPTION$
|
||||
* READKEY() es usado despu‚s que un READ ha terminado para determinar
|
||||
* la tecla de salida.
|
||||
* Si el buffer del GET fu‚ actualizado durante el READ, el valor 256
|
||||
* es agregado al c¢digo de retorno.
|
||||
*
|
||||
* <table>
|
||||
* Tecla de C¢digo de Retorno C¢digo de Retorno
|
||||
* Salida (no actualizado) (actualizado)
|
||||
*
|
||||
* Up 4 260
|
||||
* Down 5 261
|
||||
* Page-Up 6 262
|
||||
* Page-Down 7 263
|
||||
* Ctrl Page-Up 34 290
|
||||
* Ctrl Page-Down 35 291
|
||||
* Esc 12 268
|
||||
* Ctrl End 14 270
|
||||
* Enter 15 271
|
||||
* Key >= 32 15 271
|
||||
* de otro modo 0 0
|
||||
* </table>
|
||||
* READKEY() es una funci¢n de compatibilidad, as¡ que trate de no
|
||||
* usarla. READKEY() es superada por LASTKEY() la que retorna el c¢digo
|
||||
* de INKEY() para esa tecla. UPDATED() podr¡a ser usado para encontrar
|
||||
* si el buffer GET hab¡a cambiado durante el READ.
|
||||
* $STATUS$
|
||||
* R
|
||||
* $COMPLIANCE$
|
||||
* READKEY() es compatible con CA-Clipper 5.3
|
||||
* $FILES$
|
||||
* La librer¡a es rtl
|
||||
* $SEEALSO$
|
||||
* @...GET,INKEY(),LASTKEY(),READ,READEXIT(),UPDATED()
|
||||
* $END$
|
||||
*/
|
||||
|
||||
/* $DOC$
|
||||
* $FUNCNAME$
|
||||
* MROW()
|
||||
* $CATEGORY$
|
||||
* Entrada de Consola
|
||||
* $ONELINER$
|
||||
* Retorna la fila de posici¢n del cursor del mouse.
|
||||
* $SYNTAX$
|
||||
* MROW() --> nFilaMouse
|
||||
* $ARGUMENTS$
|
||||
* Ninguno
|
||||
* $RETURNS$
|
||||
* <nFilaMouse> la fila de posici¢n del cursor del mouse.
|
||||
* $DESCRIPTION$
|
||||
* Esta funci¢n retorna el fila de posicion actual del cursor del mouse
|
||||
* En sistemas gr ficos el valor representa filas de pixels.
|
||||
* En sistemas basados en caracteres el valor representa filas de
|
||||
* caracteres como en Clipper.
|
||||
* $EXAMPLES$
|
||||
* IF MROW() < 1
|
||||
* ? "El Mouse esta en la fila superior!"
|
||||
* ENDIF
|
||||
*
|
||||
* $STATUS$
|
||||
* R
|
||||
* $COMPLIANCE$
|
||||
* MROW() es compatible con CA-Clipper 5.3, pero ha sido extendido para
|
||||
* trabajar sobre sistemas gr ficos tan bien como en sistemas basados
|
||||
* en caracteres.
|
||||
* $PLATFORMS$
|
||||
* Todas.
|
||||
* $FILES$
|
||||
* La librer¡a es rtl
|
||||
* $SEEALSO$
|
||||
* MCOL()
|
||||
* $END$
|
||||
*/
|
||||
|
||||
/* $DOC$
|
||||
* $FUNCNAME$
|
||||
* MCOL()
|
||||
* $CATEGORY$
|
||||
* Entrada de Consola
|
||||
* $ONELINER$
|
||||
* Retorna la columna de posici¢n del cursor del mouse.
|
||||
* $SYNTAX$
|
||||
* MCOL() --> nColumnaMouse
|
||||
* $ARGUMENTS$
|
||||
* Ninguno.
|
||||
* $RETURNS$
|
||||
* <nColumnaMouse> la columna de posici¢n del cursor del mouse.
|
||||
* $DESCRIPTION$
|
||||
* Esta funci¢n retorna la columna de posici¢n actual del cursor del
|
||||
* mouse.
|
||||
* En sistemas gr ficos el valor representa filas de pixels.
|
||||
* En sistemas basados en caracteres el valor representa filas de
|
||||
* caracteres como en Clipper.
|
||||
* $EXAMPLES$
|
||||
* IF MCOL() < 1
|
||||
* ? "El Mouse esta sobre el margen izquierdo!"
|
||||
* ENDIF
|
||||
* $STATUS$
|
||||
* R
|
||||
* $COMPLIANCE$
|
||||
* MCOL() es compatible con CA-Clipper 5.3, pero ha sido extendido para
|
||||
* trabajar sobre sistemas gr ficos tan bien como en sistemas basados
|
||||
* en caracteres.
|
||||
* $PLATFORMS$
|
||||
* Todas.
|
||||
* $FILES$
|
||||
* La librer¡a es rtl
|
||||
* $SEEALSO$
|
||||
* MROW()
|
||||
* $END$
|
||||
*/
|
||||
|
||||
|
||||
99
harbour/doc/es/macro.txt
Normal file
99
harbour/doc/es/macro.txt
Normal file
@@ -0,0 +1,99 @@
|
||||
/*
|
||||
* $Id$
|
||||
*/
|
||||
|
||||
/*
|
||||
* Las siguientes partes son derechos adquiridos de sus autores individuales.
|
||||
* www - http://www.harbour-project.org
|
||||
*
|
||||
* Copyright 2002 Alejandro de G rate <alex_degarate@hotmail.com>
|
||||
* Documentaci¢n en Espa¤ol de:
|
||||
* Compilador Macro, HB_SETMACRO()
|
||||
*
|
||||
* Vea doc/license.txt por los t‚rminos de la licencia.
|
||||
*
|
||||
*/
|
||||
|
||||
/* $DOC$
|
||||
* $FUNCNAME$
|
||||
* Compilador Macro
|
||||
* $CATEGORY$
|
||||
* Documento
|
||||
* $ONELINER$
|
||||
* Compilador Macro
|
||||
* $DESCRIPTION$
|
||||
*
|
||||
* <b>Invocando al compilador de Macros: </b>
|
||||
* =================================
|
||||
*
|
||||
* &variable
|
||||
* ¢
|
||||
* &( expresi¢n )
|
||||
* ¢
|
||||
* &variable.text
|
||||
*
|
||||
* $END$
|
||||
*/
|
||||
|
||||
/* $DOC$
|
||||
* $FUNCNAME$
|
||||
* HB_SETMACRO()
|
||||
* $CATEGORY$
|
||||
* Compilador Macro
|
||||
* $ONELINER$
|
||||
* Habilita/Inhabilita las caracter¡sticas del Compilador Macro
|
||||
* $SYNTAX$
|
||||
* HB_SETMACRO( <nOpcion>, [<lOnOff>] ) --> <lSeteoAnterior>
|
||||
* $ARGUMENTS$
|
||||
* <nOpcion> Una de las constantes HB_SM_* definidas en set.ch.
|
||||
*
|
||||
* <lOnOff> Usar .T. para habilitar ¢ .F. para Inhabilitar una
|
||||
* caracter¡stica.
|
||||
* $RETURNS$
|
||||
* HB_SETMACRO() retorna el estado anterior de la caracter¡stica
|
||||
* solicitada.
|
||||
* $DESCRIPTION$
|
||||
* Esta funci¢n Habilita / Inhabilita algunas de las caracter¡sticas
|
||||
* del Compilador de Macros. Harbour extiende las caracter¡sticas para
|
||||
* macros comparadas con el conjunto original en Clipper.
|
||||
* Habilitando / Inhabilitando algunas de ellas permite mantener una
|
||||
* estricta compatibilidad con Clipper.
|
||||
*
|
||||
* Las caracter¡sticas disponibles son:
|
||||
*
|
||||
* <b>HB_SM_HARBOUR</b> - Habilita las extensiones de Harbour:
|
||||
* operadores: ++, --, +=, -=, *=, /=, ^=
|
||||
* objetos: asignaciones a una variable de instancia
|
||||
*
|
||||
* <b>HB_SM_XBASE</b> - Habilita extensiones de otros dialectos xbase:
|
||||
* Expansi¢n de listas de expresiones
|
||||
*
|
||||
* <b>HB_SM_SHORTCUTS</b> - Habilita la evaluaci¢n optimizada de los
|
||||
* operadores l¢gicos (.AND., .OR.)
|
||||
*
|
||||
* <b>HB_SM_PREPROC</b> - Habilita el preprocesamiento de comandos
|
||||
* Esto es significativo si Harbour es compilado con la bandera
|
||||
* HB_MACRO_STATEMENTS establecida.
|
||||
*
|
||||
* $EXAMPLES$
|
||||
* INIT PROCEDURE IWANTCLIPPER()
|
||||
* HB_SETMACRO( HB_SM_HARBOUR, .F. )
|
||||
* HB_SETMACRO( HB_SM_XBASE, .F. )
|
||||
* RETURN
|
||||
*
|
||||
* </fixed>
|
||||
* $STATUS$
|
||||
* R
|
||||
* $COMPLIANCE$
|
||||
* Esta funci¢n es una extensi¢n de Harbour.
|
||||
* $PLATFORMS$
|
||||
* Todas
|
||||
* $FILES$
|
||||
* El archivo de cabecera es ..\include\set.ch
|
||||
* La Librer¡a es macro
|
||||
* $SEEALSO$
|
||||
* Compilador Macro
|
||||
* $END$
|
||||
*/
|
||||
|
||||
|
||||
197
harbour/doc/es/memvar2.txt
Normal file
197
harbour/doc/es/memvar2.txt
Normal file
@@ -0,0 +1,197 @@
|
||||
/*
|
||||
* $Id$
|
||||
*/
|
||||
|
||||
/*
|
||||
* Las siguientes partes son derechos adquiridos de sus autores individuales.
|
||||
* www - http://www.harbour-project.org
|
||||
*
|
||||
* Copyright 2003 Alejandro de G rate <alex_degarate@hotmail.com>
|
||||
* Documentaci¢n en Espa¤ol de:
|
||||
* FIELD, LOCAL, MEMVAR
|
||||
*
|
||||
* Vea doc/license.txt por los t‚rminos de la licencia.
|
||||
*
|
||||
*/
|
||||
|
||||
/* $DOC$
|
||||
* $COMMANDNAME$
|
||||
* FIELD
|
||||
* $CATEGORY$
|
||||
* Comando
|
||||
* $ONELINER$
|
||||
* Declara una lista de nombres de campo de una base de datos
|
||||
* $SYNTAX$
|
||||
* FIELD <xField> [,<xFieldn...> [in <cDatabase>]
|
||||
* $ARGUMENTS$
|
||||
* <xField> Un nombre de campo válido
|
||||
*
|
||||
* <xFieldn> Nombres de campo adicionales
|
||||
*
|
||||
* <cDatabase> Un nombre de alias válido
|
||||
* $RETURNS$
|
||||
* Nada
|
||||
* $DESCRIPTION$
|
||||
* Este comando declara los nombres de los campos <xField> y siguientes
|
||||
* <xFieldn> con una identificador opcional de alias <cDatabase> para
|
||||
* cada uno.
|
||||
* Este comando le permite a Harbour resolver cualquier referencia a un
|
||||
* campo especificado en la lista de campos, viéndolo como un campo
|
||||
* cuando no es referenciado por un alias.
|
||||
* Si un campo no está mencionado en la lista y no está explicitamente
|
||||
* marcado con el identificador de alias, éste puede ser visto como una
|
||||
* variable de memoria, lo cual puede causar errores de ejecución.
|
||||
*
|
||||
* Este comando no tiene efecto sobre variables de memoria ó sobre
|
||||
* referencias a campos metidos dentro de una macro-expresión.
|
||||
* $EXAMPLES$
|
||||
* FUNCTION MAIN
|
||||
* FIELD iD
|
||||
* FIELD Name
|
||||
* USE TESTS NEW
|
||||
* name := "Sales"
|
||||
* Id := 5
|
||||
* USE
|
||||
* RETURN NIL
|
||||
* $TESTS$
|
||||
* Ver ../tests/testwarn.prg
|
||||
* $STATUS$
|
||||
* R
|
||||
* $COMPLIANCE$
|
||||
* Este comando trabaja exactamente como en CA-Clipper.
|
||||
* $PLATFORMS$
|
||||
* Todas
|
||||
* $FILES$
|
||||
* Ninguno
|
||||
* $SEEALSO$
|
||||
* MEMVAR,PRIVATE,PUBLIC,STATIC
|
||||
* $END$
|
||||
*/
|
||||
|
||||
|
||||
/* $DOC$
|
||||
* $COMMANDNAME$
|
||||
* LOCAL
|
||||
* $CATEGORY$
|
||||
* Comando
|
||||
* $ONELINER$
|
||||
* Crea e inicializa una variable de memoria ó un array LOCAL
|
||||
* $SYNTAX$
|
||||
* LOCAL <xVar> [:= <xInit> ]
|
||||
* LOCAL <xVar1>[:= <xInit1>], ..., <xVarN>[:= <xInitN>]
|
||||
* $ARGUMENTS$
|
||||
* <xVar> Nombre de variable de Memoria ó array.
|
||||
*
|
||||
* <xInit> Valor a ser asignado a la variable ó array
|
||||
* $RETURNS$
|
||||
* Nada
|
||||
* $DESCRIPTION$
|
||||
* Este comando Crea una variable de memoria ó un array LOCAL
|
||||
* El nombre de cualquiera es especificado en <xVar>.
|
||||
* Si más de una variable está siendo inicializada con la sentencia
|
||||
* LOCAL, separe cada una de ellas con una coma.
|
||||
* Si una variable ó un array le va a ser asignado un valor de inicio
|
||||
* esa expresión puede ser especificada en <xInit>, usando el operador
|
||||
* de asignación en línea <:=>
|
||||
*
|
||||
* Nota:
|
||||
* Si el modo de compilación "Fuertemente Tipeado" (Strong type) es
|
||||
* usado, el compilador chequeará si el valor recibido coincide con el
|
||||
* tipo especificado en <xType>.
|
||||
*
|
||||
* Las Variables LOCALes son símbolos generados en tiempo de ejecución
|
||||
* y son resueltos en tiempo de compilación (???).
|
||||
* La visibilidad y tiempo de vida de una variable ó array LOCAL está
|
||||
* limitada a la función ó procedimiento en la cual ésta es definida.
|
||||
*
|
||||
* Ninguna macro-expansión es permitida de una sentencia de declaración
|
||||
* LOCAL.
|
||||
*
|
||||
* Ningún comando de Harbour distinto a FUNCTION, PROCEDURE, PUBLIC,
|
||||
* PRIVATE, PARAMETERS, MEMVAR, STATIC y FIELD, pueden preceder a la
|
||||
* sentencia LOCAL (esto esta mal)
|
||||
*
|
||||
* Las referencias a un array LOCAL pueden no ser inicializadas (por
|
||||
* ej. asignarle un valor) en la misma línea de comando junto con la
|
||||
* sentencia LOCAL. Esto puede ser hecho luego en el programa.
|
||||
*
|
||||
* Variables y arrays de tipo LOCAL no son afectadas por el comando
|
||||
* RELEASE.
|
||||
* $EXAMPLES$
|
||||
* Function Main2()
|
||||
* Local n , lVar
|
||||
*
|
||||
* n := IIF( lVar, 'A', 3 )
|
||||
* n := 2
|
||||
* n := 'a'
|
||||
* n := seconds() + 2
|
||||
* n := int( seconds() + 2 )
|
||||
* Return( NIL )
|
||||
* $TESTS$
|
||||
* Ver ../tests/testwarn.prg por más ejemplos
|
||||
* $STATUS$
|
||||
* R
|
||||
* $COMPLIANCE$
|
||||
* Este comando trabaja exactamente como en CA-Clipper.
|
||||
* $PLATFORMS$
|
||||
* Todas
|
||||
* $FILES$
|
||||
* Ninguno
|
||||
* $SEEALSO$
|
||||
* FIELD,PRIVATE,PUBLIC,STATIC,MEMVAR
|
||||
* $END$
|
||||
*/
|
||||
|
||||
/* $DOC$
|
||||
* $COMMANDNAME$
|
||||
* MEMVAR
|
||||
* $CATEGORY$
|
||||
* Comando
|
||||
* $ONELINER$
|
||||
* Declara variables PRIVATE, PUBLIC y arrays.
|
||||
* $SYNTAX$
|
||||
* MEMVAR <xVar>
|
||||
* $ARGUMENTS$
|
||||
* <xVar> Nombre de variable de Memoria
|
||||
* $RETURNS$
|
||||
* Nada
|
||||
* $DESCRIPTION$
|
||||
* Este comando le dice al compilador como resolver alguna referencia
|
||||
* a una variable de memoria designada dentro de esta lista ó si posee
|
||||
* un alias explícito con el prefijo "M->" ó bien "MEMVAR->"
|
||||
* Solamente aquellas variables de memoria que no contengan ese prefijo
|
||||
* son afectadas por este comando. Aquellas variables de memoria dentro
|
||||
* de expansiones macro, no son afectadas por este comando.
|
||||
*
|
||||
* La declaración MEMVAR debe aparecer antes que cualquier comando
|
||||
* ejecutable; esta es similar a las sentencias LOCAL, STATIC, FIELD,
|
||||
* PARAMETERS, FUNCTION y PROCEDURE
|
||||
* $EXAMPLES$
|
||||
* MEMVAR y As Numeric
|
||||
* Function Main2()
|
||||
* LOCAL n , lVar
|
||||
*
|
||||
* n := IIF( lVar, 'A', 3 )
|
||||
* n := 2
|
||||
* n := 'a'
|
||||
* n := seconds() + 2
|
||||
* n := int( seconds() + 2 )
|
||||
* y := n
|
||||
* ? y
|
||||
* Return( NIL )
|
||||
* $TESTS$
|
||||
* Ver ../tests/testwarn.prg por más ejemplos
|
||||
* $STATUS$
|
||||
* R
|
||||
* $COMPLIANCE$
|
||||
* Este comando trabaja exactamente como en CA-Clipper.
|
||||
* $PLATFORMS$
|
||||
* Todas
|
||||
* $FILES$
|
||||
* Ninguno
|
||||
* $SEEALSO$
|
||||
* LOCAL,STATIC,FIELD,PRIVATE,PUBLIC
|
||||
* $END$
|
||||
*/
|
||||
|
||||
|
||||
257
harbour/doc/es/misc.txt
Normal file
257
harbour/doc/es/misc.txt
Normal file
@@ -0,0 +1,257 @@
|
||||
/*
|
||||
* $Id$
|
||||
*/
|
||||
|
||||
/*
|
||||
* Las siguientes partes son derechos adquiridos de sus autores individuales.
|
||||
* www - http://www.harbour-project.org
|
||||
*
|
||||
* Copyright 2003 Alejandro de G rate <alex_degarate@hotmail.com>
|
||||
* Documentaci½n en Espa¤ol de:
|
||||
* OS(), VERSION(), GETENV(), __RUN(), TONE(), RUN
|
||||
*
|
||||
* Copyright 2000 Chen Kedem <niki@actcom.co.il>
|
||||
* Documentaci¢n en Ingl‚s de: TONE()
|
||||
*
|
||||
* Vea doc/license.txt por los t‚rminos de la licencia.
|
||||
*
|
||||
*/
|
||||
|
||||
/* $DOC$
|
||||
* $FUNCNAME$
|
||||
* OS()
|
||||
* $ONELINER$
|
||||
* Retorna el sistema operativo subyacente.
|
||||
* $SYNTAX$
|
||||
* OS() --> <cSistemaOperativo>
|
||||
* $CATEGORY$
|
||||
* DOS
|
||||
* $RETURNS$
|
||||
* <cSistemaOperativo> el actual sistema operativo
|
||||
* $DESCRIPTION$
|
||||
* Esta funci¢n devuelve el actual sistema operativo como una cadena
|
||||
* de caracteres.
|
||||
* $EXAMPLES$
|
||||
* ? OS()
|
||||
* $TESTS$
|
||||
* $STATUS$
|
||||
* R
|
||||
* $COMPLIANCE$
|
||||
* Esta es una funci¢n compatible con CA-Clipper.
|
||||
* $PLATFORMS$
|
||||
* Todas
|
||||
* $FILES$
|
||||
* El c¢digo fuente esta en ../source/rtl/version.c
|
||||
* La librer¡a es rtl
|
||||
* $END$
|
||||
*/
|
||||
|
||||
/* $DOC$
|
||||
* $FUNCNAME$
|
||||
* VERSION()
|
||||
* $CATEGORY$
|
||||
* Entorno
|
||||
* $ONELINER$
|
||||
* Retorna la Versi¢n de HARBOUR
|
||||
* $SYNTAX$
|
||||
* VERSION() --> <HbVersion>
|
||||
* $ARGUMENTS$
|
||||
* Ninguno
|
||||
* $RETURNS$
|
||||
* <HbVersion> Cadena conteniendo la versi¢n de Harbour
|
||||
* $DESCRIPTION$
|
||||
* Esta funci¢n devuelve la actual versi¢n de Harbour.
|
||||
* $EXAMPLES$
|
||||
* // Visualiza algo similar a: Harbour Alpha build 40.0 Intl. (Flex)
|
||||
* ? QOUT( VERSION() )
|
||||
* $TESTS$
|
||||
* $STATUS$
|
||||
* S
|
||||
* $COMPLIANCE$
|
||||
* Esta es una funci¢n compatible con CA-Clipper.
|
||||
* $PLATFORMS$
|
||||
* Todas
|
||||
* $FILES$
|
||||
* El c¢digo fuente esta en ../source/rtl/version.c
|
||||
* La librer¡a es rtl
|
||||
* $SEEALSO$
|
||||
* OS()
|
||||
* $END$
|
||||
*/
|
||||
|
||||
/* $DOC$
|
||||
* $FUNCNAME$
|
||||
* GETENV()
|
||||
* $CATEGORY$
|
||||
* Entorno
|
||||
* $ONELINER$
|
||||
* Obtiene datos de las Variables de Entorno del Sistema Operativo
|
||||
* $SYNTAX$
|
||||
* GETENV(<cEntorno>, <cValorxDefecto> ) --> <cResultado>
|
||||
* $ARGUMENTS$
|
||||
* <cEntorno> Variable de Entorno a obtener
|
||||
*
|
||||
* <cValorxDefecto> Valor opcional a retornar si la variable <cEntorno>
|
||||
* no es encontrada.
|
||||
* $RETURNS$
|
||||
* <cResultado> Valor de la variable de Entorno
|
||||
* $DESCRIPTION$
|
||||
* Esta funci¢n produce una cadena que es el valor de la variable de
|
||||
* Entorno <cEntorno>, la cual es almacenada a nivel del sistema
|
||||
* operativo con el comando SET del mismo.
|
||||
* Si ninguna variable de Entorno puede ser encontrada, el valor que
|
||||
* retorne la funci¢n ser <cValorxDefecto> si ‚ste es pasado, ¢ de lo
|
||||
* contrario una cadena vac¡a.
|
||||
* $EXAMPLES$
|
||||
* QOUT( GETENV('PATH'))
|
||||
* QOUT( GETENV('CONFIG'))
|
||||
* QOUT( GETENV('HARBOURCMD', '-n -l -es2'))
|
||||
* </fixed>
|
||||
* $TESTS$
|
||||
* $STATUS$
|
||||
* R
|
||||
* $COMPLIANCE$
|
||||
* Esta es una funci¢n compatible con CA-Clipper.
|
||||
* El par metro <cValorxDefecto> es una extensi¢n de Harbour.
|
||||
* $PLATFORMS$
|
||||
* Todas
|
||||
* $FILES$
|
||||
* El c¢digo fuente esta en ../source/rtl/gete.c
|
||||
* La librer¡a es rtl
|
||||
* $END$
|
||||
*/
|
||||
|
||||
/* $DOC$
|
||||
* $FUNCNAME$
|
||||
* __RUN()
|
||||
* $CATEGORY$
|
||||
* DOS
|
||||
* $ONELINER$
|
||||
* Corre/Ejecuta un programa externo.
|
||||
* $SYNTAX$
|
||||
* __RUN( <cComando> )
|
||||
* $ARGUMENTS$
|
||||
* <cComando> Comando a ejecutar
|
||||
* $DESCRIPTION$
|
||||
* Este Comando ejecuta un programa externo. Por favor aseg£rese que
|
||||
* Ud. tiene sufuciente memoria libre para poder ejecutar el programa
|
||||
* externo.
|
||||
* No lo use para correr programas que permanecen residentes (en el
|
||||
* caso del sistema operativo DOS) porque puede causar muchos problemas
|
||||
*
|
||||
* Nota: El comando RUN es preprocesado en esta funci¢n.
|
||||
* Se considera una mala pr ctica usar esta funci¢n directamente
|
||||
* Use el comando RUN en su lugar.
|
||||
* $EXAMPLES$
|
||||
* __Run( "edit " + cMyTextFile ) // Corre un Editor externo
|
||||
* __Run( "command" ) // Da el prompt del DOS (s¢lo DOS)
|
||||
* </fixed>
|
||||
* $TESTS$
|
||||
* $STATUS$
|
||||
* R
|
||||
* $COMPLIANCE$
|
||||
* Esta es una funci¢n compatible con CA-Clipper.
|
||||
* $PLATFORMS$
|
||||
* Todas
|
||||
* $FILES$
|
||||
* El c¢digo fuente esta en ../source/rtl/run.c
|
||||
* La librer¡a es rtl
|
||||
* $SEEALSO$
|
||||
* RUN
|
||||
* $END$
|
||||
*/
|
||||
|
||||
/* $DOC$
|
||||
* $FUNCNAME$
|
||||
* TONE()
|
||||
* $CATEGORY$
|
||||
* Miscelanea
|
||||
* $ONELINER$
|
||||
* Suena un tono con una frecuencia y duraci¢n especificada.
|
||||
* $SYNTAX$
|
||||
* TONE( <nFrecuencia>, <nDuracion> ) --> NIL
|
||||
* $ARGUMENTS$
|
||||
* <nFrecuencia> Un valor num‚rico no negativo que especifica la
|
||||
* frecuencia del tono en Hertzios (ciclos por segundo)
|
||||
*
|
||||
* <nDuracion> Un valor num‚rico positivo que especifica la duraci¢n
|
||||
* del tono en unidades de 1/18 avo de segundo.
|
||||
* $RETURNS$
|
||||
* TONE() siempre devuelve NIL.
|
||||
* $DESCRIPTION$
|
||||
* TONE() es una funci¢n de sonido que podr¡a ser usada para irritar
|
||||
* al usuario final, a su perro y al vecindario que lo rodea.
|
||||
* La frecuencia est limitada al rango 0 to 32767 Hz. Las frecuencias
|
||||
* por debajo de 20 Hz son inaudibles.
|
||||
* Si hay decimales en los argumentos estos se truncan.
|
||||
* $EXAMPLES$
|
||||
* IF lOk // Suena bien
|
||||
* TONE( 500, 1 )
|
||||
* TONE( 4000, 1 )
|
||||
* TONE( 2500, 1 )
|
||||
* ELSE // Suena mal
|
||||
* TONE( 300, 1 )
|
||||
* TONE( 499, 5 )
|
||||
* TONE( 700, 5 )
|
||||
* ENDIF
|
||||
* </fixed>
|
||||
* $TESTS$
|
||||
* TONE( 800, 1 ) // igual que ? CHR(7)
|
||||
* TONE( 32000, 200 ) // algun perro alrededor ?
|
||||
* TONE( 261, 1 ) // nota musical - C (DO medio)
|
||||
* TONE( 400, 0 ) // pitido corto
|
||||
* TONE( 700 ) //
|
||||
* TONE( 10, 18.2 ) // demora de 1 segundo
|
||||
* TONE( -1 ) // demora de 1/18.2 segundo
|
||||
* TONE( ) // demora de 1/18.2 segundo
|
||||
* </fixed>
|
||||
* $TESTS$
|
||||
* $STATUS$
|
||||
* S
|
||||
* $COMPLIANCE$
|
||||
* Esta es una funci¢n compatible con CA-Clipper.
|
||||
* $PLATFORMS$
|
||||
* Todas
|
||||
* $FILES$
|
||||
* La librer¡a es rtl
|
||||
* $SEEALSO$
|
||||
* CHR(),SET BELL
|
||||
* $END$
|
||||
*/
|
||||
|
||||
/* $DOC$
|
||||
* $FUNCNAME$
|
||||
* RUN
|
||||
* $CATEGORY$
|
||||
* Comando
|
||||
* $ONELINER$
|
||||
* Corre/Ejecuta un programa externo.
|
||||
* $SYNTAX$
|
||||
* RUN <cComando>
|
||||
* $ARGUMENTS$
|
||||
* <cComando> Comando a ejecutar
|
||||
* $DESCRIPTION$
|
||||
* Este Comando ejecuta un programa externo. Por favor aseg£rese que
|
||||
* Ud. tiene sufuciente memoria libre para poder ejecutar el programa
|
||||
* externo.
|
||||
* No lo use para correr programas que permanecen residentes (en el
|
||||
* caso del sistema operativo DOS) porque puede causar muchos problemas.
|
||||
* $EXAMPLES$
|
||||
* RUN "edit " + cMyTextFile // Corre un Editor externo
|
||||
* RUN "command" // Da el prompt del DOS (s¢lo DOS)
|
||||
* $TESTS$
|
||||
* $STATUS$
|
||||
* R
|
||||
* $COMPLIANCE$
|
||||
* Este es un Comando compatible con CA-Clipper.
|
||||
* $PLATFORMS$
|
||||
* Todas
|
||||
* $FILES$
|
||||
* El c¢digo fuente esta en ../source/rtl/run.c
|
||||
* La librer¡a es rtl
|
||||
* $SEEALSO$
|
||||
* RUN
|
||||
* $END$
|
||||
*/
|
||||
|
||||
|
||||
132
harbour/doc/es/nation.txt
Normal file
132
harbour/doc/es/nation.txt
Normal file
@@ -0,0 +1,132 @@
|
||||
/*
|
||||
* $Id$
|
||||
*/
|
||||
|
||||
/*
|
||||
* Las siguientes partes son derechos adquiridos de sus autores individuales.
|
||||
* www - http://www.harbour-project.org
|
||||
*
|
||||
* Copyright 2000 Alejandro de G rate <alex_degarate@hotmail.com>
|
||||
* Documentaci¢n en Espa¤ol de: ISAFFIRM(), ISNEGATIVE(), NATIONMSG()
|
||||
*
|
||||
* Copyright 1999 Jose Lalin <dezac@corevia.com>
|
||||
* Documentaci¢n en Ingles de: ISAFFIRM(), ISNEGATIVE(), NATIONMSG()
|
||||
*
|
||||
* Vea doc/license.txt por los t‚rminos de la licencia.
|
||||
*
|
||||
*/
|
||||
|
||||
/* $DOC$
|
||||
* $FUNCNAME$
|
||||
* ISAFFIRM()
|
||||
* $CATEGORY$
|
||||
* Nacion
|
||||
* $ONELINER$
|
||||
* Chequea si el caracter pasado es el caracter de afirmaci¢n
|
||||
* $SYNTAX$
|
||||
* ISAFFIRM( <cChar> ) --> <lTrueOrFalse>
|
||||
* $ARGUMENTS$
|
||||
* <cChar> es un char ¢ cadena de caracteres
|
||||
* $RETURNS$
|
||||
* <lTrueOrFalse> Verdadero si el caracter pasado es el caracter de
|
||||
* afirmaci¢n, ¢ Falso de otro modo.
|
||||
* $DESCRIPTION$
|
||||
* Esta funci¢n es usada para chequear si la entrada del usuario es
|
||||
* verdadera ¢ no, de acuerdo al m¢dulo msgxxx usado.
|
||||
* En Clipper el m¢dulo por defecto depende de la versi¢n usada, en
|
||||
* Harbour el m¢dulo por defecto es el Ingl‚s.
|
||||
* En ingl‚s la opci¢n v lida es "Y", en español "S"
|
||||
* $EXAMPLES$
|
||||
* // Esperar hasta que el usuario ingrese "Y"
|
||||
* DO WHILE ! ISAFFIRM( cYesNo )
|
||||
* ACCEPT "Esta Seguro ?: " TO cYesNo
|
||||
* END DO
|
||||
* </fixed>
|
||||
* $STATUS$
|
||||
* R
|
||||
* $COMPLIANCE$
|
||||
* Esta funci¢n es totalmente compatible con CA-Clipper.
|
||||
* $FILES$
|
||||
* La librer¡a es rtl
|
||||
* $SEEALSO$
|
||||
* ISNEGATIVE(),NATIONMSG()
|
||||
* $END$
|
||||
*/
|
||||
|
||||
/* $DOC$
|
||||
* $FUNCNAME$
|
||||
* ISNEGATIVE()
|
||||
* $CATEGORY$
|
||||
* Nacion
|
||||
* $ONELINER$
|
||||
* Chequea si el caracter pasado es el caracter de negaci¢n
|
||||
* $SYNTAX$
|
||||
* ISNEGATIVE( <cChar> ) --> <lTrueOrFalse>
|
||||
* $ARGUMENTS$
|
||||
* <cChar> es un char ¢ cadena de caracteres
|
||||
* $RETURNS$
|
||||
* <lTrueOrFalse> Verdadero si el caracter pasado es el caracter de
|
||||
* negaci¢n, ¢ Falso de otro modo.
|
||||
* $DESCRIPTION$
|
||||
* Esta funci¢n es usada para chequear si la entrada del usuario es
|
||||
* verdadera ¢ no, de acuerdo al m¢dulo msgxxx usado.
|
||||
* En Clipper el m¢dulo por defecto depende de la versi¢n usada, en
|
||||
* Harbour el m¢dulo por defecto es el Ingl‚s.
|
||||
* En ingl‚s la opci¢n v lida es "N", en español "N"
|
||||
* $EXAMPLES$
|
||||
* // Esperar hasta que el usuario ingrese "N"
|
||||
* DO WHILE ! ISNEGATIVE( cYesNo )
|
||||
* ACCEPT "Esta Seguro ?: " TO cYesNo
|
||||
* END DO
|
||||
* </fixed>
|
||||
* $STATUS$
|
||||
* R
|
||||
* $COMPLIANCE$
|
||||
* Esta funci¢n es totalmente compatible con CA-Clipper.
|
||||
* $FILES$
|
||||
* La librer¡a es rtl
|
||||
* $SEEALSO$
|
||||
* ISAFFIRM(),NATIONMSG()
|
||||
* $END$
|
||||
*/
|
||||
|
||||
/* $DOC$
|
||||
* $FUNCNAME$
|
||||
* NATIONMSG()
|
||||
* $CATEGORY$
|
||||
* Nacion
|
||||
* $ONELINER$
|
||||
* Retorna cadenas de mensajes internacionales.
|
||||
* $SYNTAX$
|
||||
* NATIONMSG( <nMsg> ) --> <cMensaje>
|
||||
* $ARGUMENTS$
|
||||
* <nMsg> es el n£mero de Mensaje que Ud. quiere obtener.
|
||||
* $RETURNS$
|
||||
* <cMensaje> Si <nMsg> es un selector de mensaje v lido, entonces se
|
||||
* retorna el mensaje.
|
||||
* Si <nMsg> es NIL, retorna "Invalid Argument", y si <nMsg> no es de
|
||||
* tipo NUMERIC esta retorna una cadena vacia.
|
||||
* $DESCRIPTION$
|
||||
* NATIONMSG() retorna las descripciones internacionales de mensajes.
|
||||
* En Clipper el m¢dulo por defecto depende de la versi¢n usada, en
|
||||
* Harbour el m¢dulo por defecto es el Ingl‚s.
|
||||
* $EXAMPLES$
|
||||
* // Visualiza "Seguro Y/N: " y espera hasta que el usuario entra "Y"
|
||||
* // Y/N es la cadena NATIONMSG( 12 ) con el m¢dulo natmsg por
|
||||
* // defecto.
|
||||
* DO WHILE ! ISAFFIRM( cYesNo )
|
||||
* ACCEPT "Esta Seguro " + NATIONMSG( 12 ) + ": " TO cYesNo
|
||||
* END DO
|
||||
* </fixed>
|
||||
* $STATUS$
|
||||
* C
|
||||
* $COMPLIANCE$
|
||||
* Esta funci¢n es totalmente compatible con CA-Clipper.
|
||||
* $FILES$
|
||||
* La librer¡a es rtl
|
||||
* $SEEALSO$
|
||||
* ISAFFIRM(),ISNEGATIVE()
|
||||
* $END$
|
||||
*/
|
||||
|
||||
|
||||
815
harbour/doc/es/objfunc.txt
Normal file
815
harbour/doc/es/objfunc.txt
Normal file
@@ -0,0 +1,815 @@
|
||||
/*
|
||||
* $Id$
|
||||
*/
|
||||
|
||||
/*
|
||||
* Las siguientes partes son derechos adquiridos de sus autores individuales.
|
||||
* www - http://www.harbour-project.org
|
||||
*
|
||||
* Copyright 2000 Alejandro de G rate <alex_degarate@hotmail.com>
|
||||
* Documentaci¢n en Espa¤ol de:
|
||||
* __objHasData(), __objHasMethod(), __objGetMsgList(),
|
||||
* __objGetMethodList(), __objGetValueList(),
|
||||
* __ObjSetValueList(), __objAddMethod(),
|
||||
* __objAddInline(), __objAddData(), __objModMethod(),
|
||||
* __objModInline(), __objDelMethod(), __objDelInline(),
|
||||
* __objDelData(), __objDerivedFrom()
|
||||
*
|
||||
* Copyright 1999-2000 Chen Kedem <niki@actcom.co.il>
|
||||
* Documentaci¢n en Ingles de:
|
||||
* __objHasData(), __objHasMethod(), __objGetMsgList(),
|
||||
* __objGetMethodList(), __objGetValueList(),
|
||||
* __ObjSetValueList(), __objAddMethod(),
|
||||
* __objAddInline(), __objAddData(), __objModMethod(),
|
||||
* __objModInline(), __objDelMethod(), __objDelInline(),
|
||||
* __objDelData(), __objDerivedFrom()
|
||||
*
|
||||
* Vea doc/license.txt por los t‚rminos de la licencia.
|
||||
*
|
||||
*/
|
||||
|
||||
/* $DOC$
|
||||
* $FUNCNAME$
|
||||
* __objHasData()
|
||||
* $CATEGORY$
|
||||
* Manejo de objetos
|
||||
* $ONELINER$
|
||||
* Determina cuando un s¡mbolo existe en un objeto como DATA
|
||||
* $SYNTAX$
|
||||
* __objHasData( <oObjeto>, <cSimbolo> ) --> lExiste
|
||||
* $ARGUMENTS$
|
||||
* <oObjeto> es el objeto a inspeccionar
|
||||
*
|
||||
* <cSimbolo> es el nombre del s¡mbolo a buscar
|
||||
* $RETURNS$
|
||||
* __objHasData() retorna .T. si el <cSimbolo> dado existe como DATA
|
||||
* (variable de instancia) en el objeto <oObjeto), y .F. si este no
|
||||
* existe.
|
||||
* $DESCRIPTION$
|
||||
* __objHasData() es una funci¢n de soporte de clases de bajo nivel
|
||||
* que le permite a Ud. encontrar si un s¡mbolo es una variable de
|
||||
* instancia en un objeto dado.
|
||||
* $EXAMPLES$
|
||||
* oB := TBrowseNew( 0, 0, 24, 79 )
|
||||
* ? __objHasData( oB, "nLeft" ) // esto deberia retornar .T.
|
||||
* ? __objHasData( oB, "lBugFree" ) // deberia ser .F.
|
||||
* ? __objHasData( oB, "Left" ) // .F. porque este es un METHOD
|
||||
* </fixed>
|
||||
* $STATUS$
|
||||
* R
|
||||
* $COMPLIANCE$
|
||||
* __objHasData() es una extensi¢n de Harbour.
|
||||
* $FILES$
|
||||
* La librer¡a es rtl
|
||||
* $SEEALSO$
|
||||
* __ObjGetMethodList(),__objGetMsgList(),__objHasMethod()
|
||||
* $END$
|
||||
*/
|
||||
|
||||
/* $DOC$
|
||||
* $FUNCNAME$
|
||||
* __objHasMethod()
|
||||
* $CATEGORY$
|
||||
* Manejo de objetos
|
||||
* $ONELINER$
|
||||
* Determina cuando un s¡mbolo existe en un objeto como METHOD
|
||||
* $SYNTAX$
|
||||
* __objHasMethod( <oObjeto>, <cSimbolo> ) --> lExist
|
||||
* $ARGUMENTS$
|
||||
* <oObjeto> es el objeto a inspeccionar
|
||||
*
|
||||
* <cSimbolo> es el nombre del s¡mbolo a buscar
|
||||
* $RETURNS$
|
||||
* __objHasMethod() retorna .T. si el <cSimbolo> dado existe como
|
||||
* METHOD (funci¢n de clase) en el Objeto <oObjeto), o .F. si este
|
||||
* no existe.
|
||||
* $DESCRIPTION$
|
||||
* __objHasMethod() es una funci¢n de soporte de clases de bajo nivel
|
||||
* que le permite a Ud. encontrar si un s¡mbolo es una funci¢n de
|
||||
* clase en un Objeto dado.
|
||||
* $EXAMPLES$
|
||||
* oB := TBrowseNew( 0, 0, 24, 79 )
|
||||
* ? __objHasMethod( oB, "nLeft" ) // .F. porque esto es DATA
|
||||
* ? __objHasMethod( oB, "FixBugs" ) // deberia ser .F.
|
||||
* ? __objHasMethod( oB, "Left" ) // esto deberia retornar .T.
|
||||
* </fixed>
|
||||
* $STATUS$
|
||||
* R
|
||||
* $COMPLIANCE$
|
||||
* __objHasMethod() es una extensi¢n de Harbour.
|
||||
* $FILES$
|
||||
* La librer¡a es rtl
|
||||
* $SEEALSO$
|
||||
* __ObjGetMethodList(),__objGetMsgList(),__objHasData()
|
||||
* $END$
|
||||
*/
|
||||
|
||||
/* $DOC$
|
||||
* $FUNCNAME$
|
||||
* __objGetMsgList()
|
||||
* $CATEGORY$
|
||||
* Manejo de objetos
|
||||
* $ONELINER$
|
||||
* Retorna los nombres de todos los DATA o METHOD para un Objeto dado
|
||||
* $SYNTAX$
|
||||
* __objGetMsgList( <oObjeto>, [<lData>], [nClassType] ) --> aNombres
|
||||
* $ARGUMENTS$
|
||||
* <oObjeto> es un Objeto a inspeccionar
|
||||
*
|
||||
* <lData> es un valor l¢gico opcional que especifica la informaci¢n
|
||||
* a retornar. Un valor .T. instruye a la funci¢n a devolver una lista
|
||||
* todos los nombres DATA, un valor de .F. instruye a la funci¢n a
|
||||
* devolver una lista de todos los nombres de METHODos.
|
||||
* El valor por defecto es .T.
|
||||
*
|
||||
* <nClassType> es un c¢digo num‚rico opcional para seleccionar cual
|
||||
* tipo de clase se va retornar.
|
||||
* El valor por defecto es HB_MSGLISTALL, retornando la lista entera.
|
||||
* $RETURNS$
|
||||
* __objGetMsgList() devuelve un array de cadenas <aNombres> con los
|
||||
* nombres de todos los DATA o todos los METHOD para un objeto dado.
|
||||
* __objGetMsgList() podr¡a retornar un array vacio, {} si el objeto
|
||||
* dado no contiene la informaci¢n solicitada.
|
||||
* $DESCRIPTION$
|
||||
* __objGetMsgList() es una funci¢n de soporte de clases de bajo nivel
|
||||
* que le permite a Ud. encontrar todas las variables de instancia o
|
||||
* los nombre de los metodos para un Objeto dado.
|
||||
*
|
||||
* Si es es especificada, la siguiente tabla muestra los valores para
|
||||
* <nClassType> que le permiten a Ud. distinguir entre DATA y
|
||||
* CLASSDATA:
|
||||
*
|
||||
* <table>
|
||||
* hboo.ch Valor Significado
|
||||
*
|
||||
* HB_MSGLISTALL 0 Todos los tipos
|
||||
* HB_MSGLISTCLASS 1 CLASSDATA solamente
|
||||
* HB_MSGLISTPURE 2 DATA solamente
|
||||
* </table>
|
||||
*
|
||||
* DATA son variables de instancia usables dentro de cada objeto desde
|
||||
* una clase, donde cada Objeto tiene sus propios DATAs.
|
||||
*
|
||||
* Las CLASSDATA son compartidas por todos los objetos desde una Clase,
|
||||
* asi el valor cambiado dentro del Objeto1 sera reflejado cuando se
|
||||
* acceda la CLASSDATA desde el Objeto2.
|
||||
* $EXAMPLES$
|
||||
* // Muestra informaci¢n sobre la clase TBrowse
|
||||
* oB := TBrowseNew( 0, 0, 24, 79 )
|
||||
* aData := __objGetMsgList( oB, .T. )
|
||||
* aClassData := __objGetMsgList( oB, .T., HB_MSGLISTCLASS )
|
||||
* aMethod := __objGetMsgList( oB, .F. )
|
||||
*
|
||||
* FOR i = 1 to len ( aData )
|
||||
* ? "nombre de DATA:", aData[ i ]
|
||||
* NEXT
|
||||
*
|
||||
* FOR i = 1 to len ( aClassData )
|
||||
* ? "nombre de CLASSDATA:", aClassData[ i ]
|
||||
* NEXT
|
||||
*
|
||||
* FOR i = 1 to len ( aMethod )
|
||||
* ? "nombre de METHOD:", aMethod[ i ]
|
||||
* NEXT
|
||||
* </fixed>
|
||||
* $STATUS$
|
||||
* R
|
||||
* $COMPLIANCE$
|
||||
* __objGetMsgList() es una extensi¢n de Harbour.
|
||||
* $FILES$
|
||||
* El archivo de cabecera es hboo.ch
|
||||
* La librer¡a es rtl
|
||||
* $SEEALSO$
|
||||
* __ObjGetMethodList(),__ObjGetValueList(),__objHasData(),__objHasMethod()
|
||||
* $END$
|
||||
*/
|
||||
|
||||
/* $DOC$
|
||||
* $FUNCNAME$
|
||||
* __objGetMethodList()
|
||||
* $CATEGORY$
|
||||
* Manejo de objetos
|
||||
* $ONELINER$
|
||||
* Retorna un array con los nombres de todos los METHOD de un Objeto
|
||||
* $SYNTAX$
|
||||
* __objGetMethodList( <oObjeto> ) --> aNombreMetodos
|
||||
* $ARGUMENTS$
|
||||
* <oObjeto> es el objeto a inspeccionar
|
||||
* $RETURNS$
|
||||
* __objGetMethodList() devuelve un array de cadenas <aNombreMetodos>
|
||||
* con los nombres de todos los METHOD para un objeto dado.
|
||||
* __objGetMethodList() podria retornar un array vacio, {} si el
|
||||
* objeto dado no contiene ningun metodo.
|
||||
* $DESCRIPTION$
|
||||
* __objGetMethodList() es una funci¢n de soporte de clases de bajo
|
||||
* nivel que le permite a Ud. encontrar todos los nombres de las
|
||||
* funciones de clase para un Objeto dado.
|
||||
* Es el equivalente a __objGetMsgList( oObjeto, .F. ).
|
||||
* $EXAMPLES$
|
||||
* // Muestra informaci¢n sobre la clase TBrowse
|
||||
* oB := TBrowseNew( 0, 0, 24, 79 )
|
||||
* aMethod := __objGetMethodList( oB )
|
||||
*
|
||||
* FOR i = 1 to len ( aMethod )
|
||||
* ? "METHOD name:", aMethod[ i ]
|
||||
* NEXT
|
||||
* </fixed>
|
||||
* $STATUS$
|
||||
* R
|
||||
* $COMPLIANCE$
|
||||
* __objGetMethodList() es una extensi¢n de Harbour.
|
||||
* $FILES$
|
||||
* La librer¡a es rtl
|
||||
* $SEEALSO$
|
||||
* __objGetMsgList(),__ObjGetValueList(),__objHasData(),__objHasMethod()
|
||||
* $END$
|
||||
*/
|
||||
|
||||
/* $DOC$
|
||||
* $FUNCNAME$
|
||||
* __objGetValueList()
|
||||
* $CATEGORY$
|
||||
* Manejo de objetos
|
||||
* $ONELINER$
|
||||
* Retorna un array con los nombres de DATA y valores de un Objeto
|
||||
* $SYNTAX$
|
||||
* __objGetValueList( <oObjeto>, [<aExcept>] ) --> aData
|
||||
* $ARGUMENTS$
|
||||
* <oObjeto> es el objeto a inspeccionar
|
||||
*
|
||||
* <aExcept> es un array opcional con los nombres de los DATA que Ud.
|
||||
* desea excluir de la inspeccion.
|
||||
* $RETURNS$
|
||||
* __objGetValueList() retorna un array bidimensional que contiene
|
||||
* pares de nombre del s¡mbolo DATA y el valor de DATA.
|
||||
* __objGetValueList() podria retornar un array vacio, {} si el
|
||||
* objeto dado no contiene la informaci¢n solicitada.
|
||||
* $DESCRIPTION$
|
||||
* __objGetValueList() es una funci¢n de soporte de clases de bajo
|
||||
* nivel que retorna un array con los nombres de DATA y valores.
|
||||
* Cada elemento del array es un par de:
|
||||
* aData[ i, HB_OO_DATA_SYMBOL ] contiene nombre del s¡mbolo
|
||||
* aData[ i, HB_OO_DATA_VALUE ] contiene el valor de DATA
|
||||
* $EXAMPLES$
|
||||
* // Muestra informaci¢n sobre la clase TBrowse
|
||||
* oB := TBrowseNew( 0, 0, 24, 79 )
|
||||
* aData := __objGetValueList( oB )
|
||||
*
|
||||
* FOR i = 1 to len ( aData )
|
||||
* ? "Nombre de DATA:", aData[ i, HB_OO_DATA_SYMBOL ], ;
|
||||
* " valor =", aData[ i, HB_OO_DATA_VALUE ]
|
||||
* NEXT
|
||||
* </fixed>
|
||||
* $STATUS$
|
||||
* R
|
||||
* $COMPLIANCE$
|
||||
* __objGetValueList() es una extensi¢n de Harbour.
|
||||
* $FILES$
|
||||
* El archivo de cabecera es hboo.ch
|
||||
* La librer¡a es rtl
|
||||
* $SEEALSO$
|
||||
* __objGetMethodList(),__objGetMsgList(),__objHasData(),__objHasMethod(),__ObjSetValueList()
|
||||
* $END$
|
||||
*/
|
||||
|
||||
/* $DOC$
|
||||
* $FUNCNAME$
|
||||
* __ObjSetValueList()
|
||||
* $CATEGORY$
|
||||
* Manejo de objetos
|
||||
* $ONELINER$
|
||||
* Establece un Objeto con un array de nombres de DATA y valores
|
||||
* $SYNTAX$
|
||||
* __ObjSetValueList( <oObjeto>, <aData> ) --> oObjeto
|
||||
* $ARGUMENTS$
|
||||
* <oObjeto> es el objeto a establecer
|
||||
*
|
||||
* <aData> es un array bidimensional con un par de variables de
|
||||
* instancia y valores para asignar a aquellas variables.
|
||||
* $RETURNS$
|
||||
* __ObjSetValueList() retorna una referencia a <oObjeto>.
|
||||
* $DESCRIPTION$
|
||||
* __ObjSetValueList() es una funci¢n de soporte de clases de bajo
|
||||
* nivel que le permite a Ud. establecer un grupo de variables de
|
||||
* instancia con valores.
|
||||
* Cada elemento del array en <aData> es un par de:
|
||||
* aData[ i, HB_OO_DATA_SYMBOL ] contiene nombre de variable a setear
|
||||
* aData[ i, HB_OO_DATA_VALUE ] contiene el nuevo valor de variable
|
||||
* $EXAMPLES$
|
||||
* // set some TBrowse instance variable
|
||||
* oB := TBrowse():New()
|
||||
* aData := array( 4, 2 )
|
||||
* aData[ 1, HB_OO_DATA_SYMBOL ] = "nTop"
|
||||
* aData[ 1, HB_OO_DATA_VALUE ] = 1
|
||||
* aData[ 2, HB_OO_DATA_SYMBOL ] = "nLeft"
|
||||
* aData[ 2, HB_OO_DATA_VALUE ] = 10
|
||||
* aData[ 3, HB_OO_DATA_SYMBOL ] = "nBottom"
|
||||
* aData[ 3, HB_OO_DATA_VALUE ] = 20
|
||||
* aData[ 4, HB_OO_DATA_SYMBOL ] = "nRight"
|
||||
* aData[ 4, HB_OO_DATA_VALUE ] = 70
|
||||
* __ObjSetValueList( oB, aData )
|
||||
* ? oB:nTop // 1
|
||||
* ? oB:nLeft // 10
|
||||
* ? oB:nBottom // 20
|
||||
* ? oB:nRight // 70
|
||||
* </fixed>
|
||||
* $STATUS$
|
||||
* R
|
||||
* $COMPLIANCE$
|
||||
* __ObjSetValueList() es una extensi¢n de Harbour.
|
||||
* $FILES$
|
||||
* El archivo de cabecera es hboo.ch
|
||||
* La librer¡a es rtl
|
||||
* $SEEALSO$
|
||||
* __ObjGetValueList()
|
||||
* $END$
|
||||
*/
|
||||
|
||||
/* $DOC$
|
||||
* $FUNCNAME$
|
||||
* __objAddMethod()
|
||||
* $CATEGORY$
|
||||
* Manejo de objetos
|
||||
* $ONELINER$
|
||||
* Agrega un METHOD a una clase ya existente
|
||||
* $SYNTAX$
|
||||
* __objAddMethod( <oObjeto>, <cMethodName>, <nFuncPtr> ) --> oObjeto
|
||||
* $ARGUMENTS$
|
||||
* <oObjeto> es el objeto con el cual se va a trabajar
|
||||
*
|
||||
* <cMethodName> es el nombre del s¡mbolo del nuevo METHOD a agregar
|
||||
*
|
||||
* <nFuncPtr> es un puntero a la funci¢n a asociar con el m‚todo
|
||||
* $RETURNS$
|
||||
* __objAddMethod() retorna una referencia a <oObjeto>.
|
||||
* $DESCRIPTION$
|
||||
* __objAddMethod() es una funci¢n de soporte de clases de bajo
|
||||
* nivel que agrega un nuevo METHOD a un Objeto.
|
||||
*
|
||||
* El <oObjeto> permanece sin cambios si el s¡mbolo con el nombre
|
||||
* <cMethodName> ya existe en <oObjeto>.
|
||||
*
|
||||
* Note que <nFuncPtr> es un especial puntero a una funci¢n que fue
|
||||
* creado usando el operador @ , vea un ejemplo a continuacion.
|
||||
* $EXAMPLES$
|
||||
* // crea un nueva clase THappy y le agrega un m‚todo Smile
|
||||
* oHappy := HBClass():New( "THappy" )
|
||||
* __objAddMethod( oHappy, "Smile", @MySmile() )
|
||||
* ? oHappy:Smile( 1 ) // :)
|
||||
* ? oHappy:Smile( 2 ) // ;)
|
||||
* ? oHappy:Smile( 3 ) // *SMILE*
|
||||
*
|
||||
* STATIC FUNCTION MySmile( nType )
|
||||
* LOCAL cSmile
|
||||
* DO CASE
|
||||
* CASE nType == 1
|
||||
* cSmile := ":)"
|
||||
* CASE nType == 2
|
||||
* cSmile := ";)"
|
||||
* CASE nType == 3
|
||||
* cSmile := "*SMILE*"
|
||||
* ENDCASE
|
||||
* RETURN cSmile
|
||||
* </fixed>
|
||||
* $STATUS$
|
||||
* R
|
||||
* $COMPLIANCE$
|
||||
* __objAddMethod() es una extensi¢n de Harbour.
|
||||
* $FILES$
|
||||
* La librer¡a es rtl
|
||||
* $SEEALSO$
|
||||
* __objAddInline(),__objAddData(),__objDelMethod(),__ObjGetMethodList(),__objGetMsgList(),__objHasMethod(),__objModMethod()
|
||||
* $END$
|
||||
*/
|
||||
|
||||
/* $DOC$
|
||||
* $FUNCNAME$
|
||||
* __objAddInline()
|
||||
* $CATEGORY$
|
||||
* Manejo de objetos
|
||||
* $ONELINER$
|
||||
* Agrega un INLINE a una clase ya existente
|
||||
* $SYNTAX$
|
||||
* __objAddInline( <oObjeto>, <cInlineName>, <bInline> ) --> oObjeto
|
||||
* $ARGUMENTS$
|
||||
* <oObjeto> es el objeto con el cual se va a trabajar
|
||||
*
|
||||
* <cInlineName> es el nombre del s¡mbolo del nuevo INLINE a agregar
|
||||
*
|
||||
* <bInline> es un codeblock a asociar con el m‚todo INLINE
|
||||
* $RETURNS$
|
||||
* __objAddInline() retorna una referencia a <oObjeto>.
|
||||
* $DESCRIPTION$
|
||||
* __objAddInline() es una funci¢n de soporte de clases de bajo
|
||||
* nivel que agrega un nuevo m‚todo INLINE a un Objeto.
|
||||
*
|
||||
* El <oObjeto> permanece sin cambios si el s¡mbolo con el nombre
|
||||
* <cInlineName> ya existe en <oObjeto>.
|
||||
* $EXAMPLES$
|
||||
* // crea un nueva clase THappy y le agrega un m‚todo INLINE Smile
|
||||
* oHappy := HBClass():New( "THappy" )
|
||||
* bInline := { | nType | { ":)", ";)", "*SMILE*" }[ nType ] }
|
||||
*
|
||||
* __objAddInline( oHappy, "Smile", bInline )
|
||||
*
|
||||
* ? oHappy:Smile( 1 ) // :)
|
||||
* ? oHappy:Smile( 2 ) // ;)
|
||||
* ? oHappy:Smile( 3 ) // *SMILE*
|
||||
* </fixed>
|
||||
* $STATUS$
|
||||
* R
|
||||
* $COMPLIANCE$
|
||||
* __objAddInline() es una extensi¢n de Harbour.
|
||||
* $FILES$
|
||||
* La librer¡a es rtl
|
||||
* $SEEALSO$
|
||||
* __objAddData(),__objAddMethod(),__objDelInline(),__ObjGetMethodList(),__objGetMsgList(),__objHasMethod() ,__objModInline()
|
||||
* $END$
|
||||
*/
|
||||
|
||||
/* $DOC$
|
||||
* $FUNCNAME$
|
||||
* __objAddData()
|
||||
* $CATEGORY$
|
||||
* Manejo de objetos
|
||||
* $ONELINER$
|
||||
* Agrega un DATA a una clase ya existente
|
||||
* $SYNTAX$
|
||||
* __objAddData( <oObjeto>, <cDataName> ) --> oObjeto
|
||||
* $ARGUMENTS$
|
||||
* <oObjeto> es el objeto con el cual se va a trabajar
|
||||
*
|
||||
* <cDataName> es el nombre del s¡mbolo del nuevo DATA a agregar
|
||||
* $RETURNS$
|
||||
* __objAddData() retorna una referencia a <oObjeto>.
|
||||
* $DESCRIPTION$
|
||||
* __objAddData() es una funci¢n de soporte de clases de bajo
|
||||
* nivel que agrega un nuevo DATA a un Objeto.
|
||||
*
|
||||
* El <oObjeto> permanece sin cambios si el s¡mbolo con el nombre
|
||||
* <cDataName> ya existe en <oObjeto>.
|
||||
* $EXAMPLES$
|
||||
* // crea un nueva clase THappy y le agrega un DATA lHappy
|
||||
* oHappy := HBClass():New( "THappy" )
|
||||
*
|
||||
* __objAddData( oHappy, "lHappy" )
|
||||
* oHappy:lHappy := .T.
|
||||
*
|
||||
* IF oHappy:lHappy
|
||||
* ? "Happy, Happy, Joy, Joy !!!"
|
||||
* ELSE
|
||||
* ? ":(..."
|
||||
* ENDIF
|
||||
* </fixed>
|
||||
* $STATUS$
|
||||
* R
|
||||
* $COMPLIANCE$
|
||||
* __objAddData() es una extensi¢n de Harbour.
|
||||
* $FILES$
|
||||
* La librer¡a es rtl
|
||||
* $SEEALSO$
|
||||
* __objAddInline(),__objAddMethod(),__objDelData(),__objGetMsgList(),__ObjGetValueList(),__objHasData(),__ObjSetValueList()
|
||||
* $END$
|
||||
*/
|
||||
|
||||
/* $DOC$
|
||||
* $FUNCNAME$
|
||||
* __objModMethod()
|
||||
* $CATEGORY$
|
||||
* Manejo de objetos
|
||||
* $ONELINER$
|
||||
* Modifica (reemplaza) un METHOD en una clase ya existente
|
||||
* $SYNTAX$
|
||||
* __objModMethod( <oObjeto>, <cMethodName>, <nFuncPtr> ) --> oObjeto
|
||||
* $ARGUMENTS$
|
||||
* <oObjeto> es el objeto con el cual se va a trabajar
|
||||
*
|
||||
* <cMethodName> es el nombre del s¡mbolo del METHOD a modificar
|
||||
*
|
||||
* <nFuncPtr> es un puntero a una nueva funci¢n a asociar con
|
||||
* el metodo.
|
||||
* $RETURNS$
|
||||
* __objModMethod() retorna una referencia a <oObjeto>.
|
||||
* $DESCRIPTION$
|
||||
* __objModMethod() es una funci¢n de soporte de clases de bajo
|
||||
* nivel que modifica un METHOD en un Objeto y lo reemplaza con
|
||||
* una nueva funci¢n.
|
||||
* El <oObjeto> permanece sin cambios si el s¡mbolo con el nombre
|
||||
* <cMethodName> ya existe en <oObjeto>.
|
||||
* __objModMethod() es usado en el mecanismo de herencia.
|
||||
*
|
||||
* Note que <nFuncPtr> es un especial puntero a una funci¢n que fue
|
||||
* creado usando el operador @ , vea un ejemplo a continuacion.
|
||||
*
|
||||
* $EXAMPLES$
|
||||
* // crea un nueva clase THappy y le agrega un m‚todo Smile
|
||||
* oHappy := HBClass():New( "THappy" )
|
||||
* __objAddMethod( oHappy, "Smile", @MySmile() )
|
||||
* ? oHappy:Smile( 1 ) // :)
|
||||
* ? oHappy:Smile( 2 ) // ;)
|
||||
*
|
||||
* // reemplaza el m‚todo Smile con una nueva funci¢n
|
||||
* __objAddMethod( oHappy, "Smile", @YourSmile() )
|
||||
* ? oHappy:Smile( 1 ) // *SMILE*
|
||||
* ? oHappy:Smile( 2 ) // *WINK*
|
||||
*
|
||||
* STATIC FUNCTION MySmile( nType )
|
||||
* LOCAL cSmile
|
||||
* DO CASE
|
||||
* CASE nType == 1
|
||||
* cSmile := ":)"
|
||||
* CASE nType == 2
|
||||
* cSmile := ";)"
|
||||
* ENDCASE
|
||||
* RETURN cSmile
|
||||
*
|
||||
* STATIC FUNCTION YourSmile( nType )
|
||||
* LOCAL cSmile
|
||||
* DO CASE
|
||||
* CASE nType == 1
|
||||
* cSmile := "*SMILE*"
|
||||
* CASE nType == 2
|
||||
* cSmile := "*WINK*"
|
||||
* ENDCASE
|
||||
* RETURN cSmile
|
||||
* </fixed>
|
||||
* $STATUS$
|
||||
* R
|
||||
* $COMPLIANCE$
|
||||
* __objModMethod() es una extensi¢n de Harbour.
|
||||
* $FILES$
|
||||
* La librer¡a es rtl
|
||||
* $SEEALSO$
|
||||
* __objAddMethod(),__objDelMethod(),__ObjGetMethodList(),__objGetMsgList(),__objHasMethod()
|
||||
* $END$
|
||||
*/
|
||||
|
||||
/* $DOC$
|
||||
* $FUNCNAME$
|
||||
* __objModInline()
|
||||
* $CATEGORY$
|
||||
* Manejo de objetos
|
||||
* $ONELINER$
|
||||
* Modifica (reemplaza) un m‚todo INLINE en una clase ya existente
|
||||
* $SYNTAX$
|
||||
* __objModInline( <oObjeto>, <cInlineName>, <bInline> ) --> oObjeto
|
||||
* $ARGUMENTS$
|
||||
* <oObjeto> es el objeto con el cual se va a trabajar
|
||||
*
|
||||
* <cInlineName> es el nombre del s¡mbolo del m‚todo INLINE a
|
||||
* modificar.
|
||||
*
|
||||
* <bInline> es un nuevo codeblock a asociar con el m‚todo INLINE
|
||||
* $RETURNS$
|
||||
* __objModInline() retorna una referencia a <oObjeto>.
|
||||
* $DESCRIPTION$
|
||||
* __objModInline() es una funci¢n de soporte de clases de bajo
|
||||
* nivel que modifica un m‚todo INLINE en un Objeto y lo reemplaza con
|
||||
* una nuevo bloque de codigo.
|
||||
*
|
||||
* El <oObjeto> permanece sin cambios si el s¡mbolo con el nombre
|
||||
* <cInlineName> no existe en <oObjeto>.
|
||||
*
|
||||
* __objModInline() es usado en el mecanismo de herencia.
|
||||
* $EXAMPLES$
|
||||
* // crea un nueva clase THappy y le agrega un m‚todo INLINE Smile
|
||||
* oHappy := HBClass():New( "THappy" )
|
||||
* bMyInline := { | nType | { ":)", ";)" }[ nType ] }
|
||||
* bYourInline := { | nType | { "*SMILE*", "*WINK*" }[ nType ] }
|
||||
*
|
||||
* __objAddInline( oHappy, "Smile", bMyInline )
|
||||
* ? oHappy:Smile( 1 ) // :)
|
||||
* ? oHappy:Smile( 2 ) // ;)
|
||||
*
|
||||
* // reemplaza el m‚todo INLINE Smile con un nuevo codeblock
|
||||
* __objModInline( oHappy, "Smile", bYourInline )
|
||||
* ? oHappy:Smile( 1 ) // *SMILE*
|
||||
* ? oHappy:Smile( 2 ) // *WINK*
|
||||
* </fixed>
|
||||
* $STATUS$
|
||||
* R
|
||||
* $COMPLIANCE$
|
||||
* __objModInline() es una extensi¢n de Harbour.
|
||||
* $FILES$
|
||||
* La librer¡a es rtl
|
||||
* $SEEALSO$
|
||||
* __objAddInline(),__objDelInline(),__ObjGetMethodList(),__objGetMsgList(),__objHasMethod()
|
||||
* $END$
|
||||
*/
|
||||
|
||||
/* $DOC$
|
||||
* $FUNCNAME$
|
||||
* __objDelMethod()
|
||||
* $CATEGORY$
|
||||
* Manejo de objetos
|
||||
* $ONELINER$
|
||||
* Borra un METHOD de una clase
|
||||
* $SYNTAX$
|
||||
* __objDelMethod( <oObjeto>, <cSimbolo> ) --> oObjeto
|
||||
* $ARGUMENTS$
|
||||
* <oObjeto> es el objeto con el cual se va a trabajar
|
||||
*
|
||||
* <cSimbolo> es el nombre del s¡mbolo del METHOD o del m‚todo
|
||||
* INLINE a ser borrado (removido) del Objeto.
|
||||
* $RETURNS$
|
||||
* __objDelMethod() retorna una referencia a <oObjeto>.
|
||||
* $DESCRIPTION$
|
||||
* __objDelMethod() es una funci¢n de soporte de clases de bajo nivel
|
||||
* que borra (remueve) un METHOD o un m‚todo INLINE de un Objeto.
|
||||
*
|
||||
* El <oObjeto> permanece sin cambios si el s¡mbolo con el nombre
|
||||
* <cSimbolo> no existe en <oObjeto>.
|
||||
*
|
||||
* __objDelInline() es exactamente la misma que __objDelMethod().
|
||||
* $EXAMPLES$
|
||||
* // crea un nueva clase THappy y le agrega un m‚todo Smile
|
||||
* oHappy := HBClass():New( "THappy" )
|
||||
*
|
||||
* __objAddMethod( oHappy, "Smile", @MySmile() )
|
||||
* ? __objHasMethod( oHappy, "Smile" ) // .T.
|
||||
*
|
||||
* // borra el m‚todo Smile
|
||||
* __objDelMethod( oHappy, "Smile" )
|
||||
* ? __objHasMethod( oHappy, "Smile" ) // .F.
|
||||
*
|
||||
* STATIC FUNCTION MySmile( nType )
|
||||
* LOCAL cSmile
|
||||
* DO CASE
|
||||
* CASE nType == 1
|
||||
* cSmile := ":)"
|
||||
* CASE nType == 2
|
||||
* cSmile := ";)"
|
||||
* ENDCASE
|
||||
* RETURN cSmile
|
||||
* </fixed>
|
||||
* $STATUS$
|
||||
* R
|
||||
* $COMPLIANCE$
|
||||
* __objDelMethod() es una extensi¢n de Harbour.
|
||||
* $FILES$
|
||||
* La librer¡a es rtl
|
||||
* $SEEALSO$
|
||||
* __objAddInline(),__objAddMethod(),__ObjGetMethodList(),__objGetMsgList(),__objHasMethod(),__objModInline(),__objModMethod()
|
||||
* $END$
|
||||
*/
|
||||
|
||||
/* $DOC$
|
||||
* $FUNCNAME$
|
||||
* __objDelInline()
|
||||
* $CATEGORY$
|
||||
* Manejo de objetos
|
||||
* $ONELINER$
|
||||
* Borra un METHOD INLINE de una clase
|
||||
* $SYNTAX$
|
||||
* __objDelInline( <oObjeto>, <cSimbolo> ) --> oObjeto
|
||||
* $ARGUMENTS$
|
||||
* <oObjeto> es el objeto con el cual se va a trabajar
|
||||
*
|
||||
* <cSimbolo> es el nombre del s¡mbolo del METHOD o del m‚todo
|
||||
* INLINE a ser borrado (removido) del Objeto.
|
||||
* $RETURNS$
|
||||
* __objDelInMethod() retorna una referencia a <oObjeto>.
|
||||
* $DESCRIPTION$
|
||||
* __objDelInMethod() es una funci¢n de soporte de clases de bajo nivel
|
||||
* que borra (remueve) un METHOD o un m‚todo INLINE de un Objeto.
|
||||
*
|
||||
* El <oObjeto> permanece sin cambios si el s¡mbolo con el nombre
|
||||
* <cSimbolo> no existe en <oObjeto>.
|
||||
* $EXAMPLES$
|
||||
* // crea un nueva clase THappy y le agrega un m‚todo Smile
|
||||
* oHappy := HBClass():New( "THappy" )
|
||||
* __objAddMethod( oHappy, "Smile", @MySmile() )
|
||||
* ? __objHasMethod( oHappy, "Smile" ) // .T.
|
||||
*
|
||||
* // borra el m‚todo Smile
|
||||
* __objDelInMethod( oHappy, "Smile" )
|
||||
* ? __objHasMethod( oHappy, "Smile" ) // .F.
|
||||
*
|
||||
* STATIC FUNCTION MySmile( nType )
|
||||
* LOCAL cSmile
|
||||
* DO CASE
|
||||
* CASE nType == 1
|
||||
* cSmile := ":)"
|
||||
* CASE nType == 2
|
||||
* cSmile := ";)"
|
||||
* ENDCASE
|
||||
* RETURN cSmile
|
||||
* </fixed>
|
||||
* $STATUS$
|
||||
* R
|
||||
* $COMPLIANCE$
|
||||
* __objDelMethod() es una extensi¢n de Harbour.
|
||||
* $FILES$
|
||||
* La librer¡a es rtl
|
||||
* $SEEALSO$
|
||||
* __objAddInline(),__objAddMethod(),__ObjGetMethodList(),__objGetMsgList(),__objHasMethod(),__objModInline(),__objModMethod()
|
||||
* $END$
|
||||
*/
|
||||
|
||||
/* $DOC$
|
||||
* $FUNCNAME$
|
||||
* __objDelData()
|
||||
* $CATEGORY$
|
||||
* Manejo de objetos
|
||||
* $ONELINER$
|
||||
* Borra un DATA (variable de instancia) de una clase
|
||||
* $SYNTAX$
|
||||
* __objDelMethod( <oObjeto>, <cDataName> ) --> oObjeto
|
||||
* $ARGUMENTS$
|
||||
* <oObjeto> es el objeto con el cual se va a trabajar
|
||||
*
|
||||
* <cDataName> es el nombre del s¡mbolo DATA a ser borrado
|
||||
* (removido) del Objeto.
|
||||
* $RETURNS$
|
||||
* __objDelData() retorna una referencia a <oObjeto>.
|
||||
* $DESCRIPTION$
|
||||
* __objDelData() es una funci¢n de soporte de clases de bajo nivel
|
||||
* que borra (remueve) un DATA de un Objeto.
|
||||
*
|
||||
* El <oObjeto> permanece sin cambios si el s¡mbolo con el nombre
|
||||
* <cDataName> no existe en <oObjeto>.
|
||||
* $EXAMPLES$
|
||||
* // crea un nueva clase THappy y le agrega un DATA lHappy
|
||||
* oHappy := HBClass():New( "THappy" )
|
||||
*
|
||||
* __objAddData( oHappy, "lHappy" )
|
||||
* ? __objHasData( oHappy, "lHappy" ) // .T.
|
||||
*
|
||||
* // borra el DATA, lHappy
|
||||
* __objDelData( oHappy, "lHappy" )
|
||||
* ? __objHasData( oHappy, "lHappy" ) // .F.
|
||||
* </fixed>
|
||||
* $STATUS$
|
||||
* R
|
||||
* $COMPLIANCE$
|
||||
* __objDelData() es una extensi¢n de Harbour.
|
||||
* $FILES$
|
||||
* La librer¡a es rtl
|
||||
* $SEEALSO$
|
||||
* __objAddData(),__objGetMsgList(),__ObjGetValueList(),__objHasData(),__ObjSetValueList()
|
||||
* $END$
|
||||
*/
|
||||
|
||||
/* $DOC$
|
||||
* $FUNCNAME$
|
||||
* __objDerivedFrom()
|
||||
* $CATEGORY$
|
||||
* Manejo de objetos
|
||||
* $ONELINER$
|
||||
* Determina cuando una clase es derivada de otra clase
|
||||
* $SYNTAX$
|
||||
* __objDerivedFrom( <oObjeto>, <xSuper> ) --> lIsParent
|
||||
* $ARGUMENTS$
|
||||
* <oObjeto> es el objeto a inspeccionar
|
||||
*
|
||||
* <xSuper> es el objeto que puede ser un padre. <xSuper> puede
|
||||
* ser o bien un Objeto o una cadena de caracteres con el
|
||||
* nombre de la clase.
|
||||
* $RETURNS$
|
||||
* __objDerivedFrom() retorna un valor logico TRUE (.T.) si el
|
||||
* <oObjeto> es derivado de <xSuper>.
|
||||
* $DESCRIPTION$
|
||||
* __objDerivedFrom() es una funci¢n de soporte de clases de bajo
|
||||
* nivel que chequea si una clase es una Superclase de la otra, o en
|
||||
* otras palabras si la clase <oObjeto> es una clase hija o
|
||||
* descendiente de <xSuper>.
|
||||
* $EXAMPLES$
|
||||
* // Crea tres clases y chequea sus relaciones
|
||||
*
|
||||
* #include "hbclass.ch"
|
||||
* FUNCTION main()
|
||||
* LOCAL oSuper, oObjeto, oDress
|
||||
* oSuper := TMood():New()
|
||||
* oObjeto := THappy():New()
|
||||
* oDress := TShirt():New()
|
||||
* ? __objDerivedFrom( oObjeto, oSuper ) // .T.
|
||||
* ? __objDerivedFrom( oSuper, oObjeto ) // .F.
|
||||
* ? __objDerivedFrom( oObjeto, oDress ) // .F.
|
||||
* RETURN NIL
|
||||
*
|
||||
* CLASS TMood
|
||||
* METHOD New() INLINE Self
|
||||
* ENDCLASS
|
||||
*
|
||||
* CLASS THappy FROM TMood
|
||||
* METHOD Smile() INLINE qout( "*smile*" )
|
||||
* ENDCLASS
|
||||
*
|
||||
* CLASS TShirt
|
||||
* DATA Color
|
||||
* DATA Size
|
||||
* METHOD New() INLINE Self
|
||||
* ENDCLASS
|
||||
* </fixed>
|
||||
* $STATUS$
|
||||
* R
|
||||
* $COMPLIANCE$
|
||||
* __objDerivedFrom() es una extensi¢n de Harbour.
|
||||
* $FILES$
|
||||
* La librer¡a es rtl
|
||||
* $SEEALSO$
|
||||
* __objHasData(),__ObjHasMethod()
|
||||
* $END$
|
||||
*/
|
||||
|
||||
|
||||
234
harbour/doc/es/rdd.txt
Normal file
234
harbour/doc/es/rdd.txt
Normal file
@@ -0,0 +1,234 @@
|
||||
/*
|
||||
* $Id$
|
||||
*/
|
||||
|
||||
/*
|
||||
* Las siguientes partes son derechos adquiridos de sus autores individuales.
|
||||
* www - http://www.harbour-project.org
|
||||
*
|
||||
* Copyright 2003 Alejandro de G rate <alex_degarate@hotmail.com>
|
||||
* Documentaci¢n en Espa¤ol de:
|
||||
* DB*(), ORD*(), RDD*()
|
||||
*
|
||||
* Copyright 1999 Luiz Rafael Culik <culik@sl.conex.net>
|
||||
* Documentaci¢n en Ingl‚s de:
|
||||
* DB*(), ORD*(), RDD*()
|
||||
*
|
||||
* Vea doc/license.txt por los t‚rminos de la licencia.
|
||||
*
|
||||
*/
|
||||
|
||||
/* $DOC$
|
||||
* $FUNCNAME$
|
||||
* RDDLIST()
|
||||
* $CATEGORY$
|
||||
* Base de Datos
|
||||
* $ONELINER$
|
||||
* Retorna un array con los Manejadores de Bases de Datos disponibles
|
||||
* $SYNTAX$
|
||||
* RDDLIST([<nTipoRDD>]) --> aRDDLista
|
||||
* $ARGUMENTS$
|
||||
* <nTipoRDD> es un entero que representa el tipo de RDD que Ud. desea
|
||||
* listar. Las constantes RDT_FULL y RDT_TRANSFER
|
||||
* representan los dos tipos de RDDs actualmente disponibles
|
||||
*
|
||||
* Resumen de Tipo de RDDs
|
||||
* ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
||||
* Constante Valor Significado
|
||||
* ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
||||
* RDT_FULL 1 Implementaci¢n Completa de RDD
|
||||
* RDT_TRANSFER 2 Solamente driver Importar/Exportar
|
||||
* ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
||||
*
|
||||
* RDT_FULL identifica a los RDDs que tienen todas las capacidades que
|
||||
* se asocian con un RDD.
|
||||
*
|
||||
* RDT_TRANSFER identifica a RDDs de capcidad limitada. Estos solamente
|
||||
* pueden transferir registros entre archivos. Ud. no puede usar estos
|
||||
* limitados drivers para abrir un archivo en un rea de trabajo.
|
||||
* Los manejadores SDF y DELIM son ejemplos de este tipo de RDD.
|
||||
* Ellos solamente son usados en la implementaci¢n de APPEND FROM y
|
||||
* COPY TO con archivos SDF ¢ DELIMITED.
|
||||
* $RETURNS$
|
||||
* RDDLIST() retorna un array unidimensional de los nombres de RDD
|
||||
* registrados con la aplicaci¢n como <nTipoRDD>.
|
||||
* $DESCRIPTION$
|
||||
* RDDLIST() es una funci¢n que devuelve una array de una dimensi¢n
|
||||
* que contiene los nombres de todos los RDD disponibles.
|
||||
*
|
||||
* Si Ud. no especifica <nTipoRDD>, ser n devueltos todos los RDD
|
||||
* disponibles sin importar el tipo.
|
||||
* $EXAMPLES$
|
||||
* En este ejemplo RDDLIST() retorna un array conteniendo las cadenas
|
||||
* de caracteres: "DBF", "SDF", "DELIM", "DBFCDX", and "DBFNTX":
|
||||
*
|
||||
* REQUEST DBFCDX
|
||||
* .
|
||||
* . < sentencias >
|
||||
* .
|
||||
* aRDDs := RDDLIST() // Retorna
|
||||
* // {"DBF", SDF", "DELIM", "DBFCDX", "DBFNTX" }
|
||||
*
|
||||
*
|
||||
* En este ejemplo RDDLIST() retorna un array conteniendo las
|
||||
* cadenas de caracteres: "SDF" and "DELIM":
|
||||
*
|
||||
* #include "rddsys.ch"
|
||||
* .
|
||||
* . < sentencias >
|
||||
* .
|
||||
* aImpExp := RDDLIST( RDT_TRANSFER )
|
||||
*
|
||||
* $TESTS$
|
||||
*
|
||||
* $STATUS$
|
||||
* R
|
||||
* $COMPLIANCE$
|
||||
*
|
||||
* $SEEALSO$
|
||||
* RDDNAME()
|
||||
* $INCLUDE$
|
||||
* El archivo de cabecera es RDDSYS.CH
|
||||
* $END$
|
||||
*/
|
||||
|
||||
/* $DOC$
|
||||
* $FUNCNAME$
|
||||
* RDDNAME()
|
||||
* $CATEGORY$
|
||||
* Base de Datos
|
||||
* $ONELINER$
|
||||
* Retorna el nombre del RDD actualmente activo
|
||||
* $SYNTAX$
|
||||
* RDDNAME() --> cNombreRDD
|
||||
* $ARGUMENTS$
|
||||
* Ninguno
|
||||
* $RETURNS$
|
||||
* Retorna una cadena de caracteres, el nombre registrado del RDD activo
|
||||
* en el rea de trabajo actual ¢ en el rea especificada.
|
||||
* $DESCRIPTION$
|
||||
* RDDNAME() es una funci¢n que devuelve una cadena de caracteres con el
|
||||
* nombre registrado del RDD activo en el rea de trabajo actual ¢ en el
|
||||
* rea especificada.
|
||||
*
|
||||
* Ud. puede especificar un rea de trabajo distinta de la actual usando
|
||||
* un alias con la funci¢n.
|
||||
* $EXAMPLES$
|
||||
* USE Customer VIA "DBFNTX" NEW
|
||||
* USE Sales VIA "DBFCDX" NEW
|
||||
*
|
||||
* ? RDDNAME() // Retorna: DBFCDX (area actual)
|
||||
* ? Customer->( RDDNAME() ) // Retorna: DBFNTX (area especificada)
|
||||
* ? Sales->( RDDNAME() ) // Retorna: DBFCDX (area especificada)
|
||||
* $TESTS$
|
||||
*
|
||||
* $STATUS$
|
||||
* R
|
||||
* $COMPLIANCE$
|
||||
*
|
||||
* $SEEALSO$
|
||||
* RDDLIST()
|
||||
* $INCLUDE$
|
||||
*
|
||||
* $END$
|
||||
*/
|
||||
|
||||
/* $DOC$
|
||||
* $FUNCNAME$
|
||||
* RDDSETDEFAULT()
|
||||
* $CATEGORY$
|
||||
* Base de Datos
|
||||
* $ONELINER$
|
||||
* Establece ¢ retorna el RDD por defecto para la aplicaci¢n.
|
||||
* $SYNTAX$
|
||||
* RDDSETDEFAULT( [<cNewDefaultRDD>] ) --> cPreviousDefaultRDD
|
||||
*
|
||||
* $ARGUMENTS$
|
||||
* <cNewDefaultRDD> es una cadena de caracteres, el nombre del RDD que
|
||||
* va a ser hecho el nuevo RDD por defecto para la
|
||||
* aplicaci¢n.
|
||||
* $RETURNS$
|
||||
* RDDSETDEFAULT() retorna una cadena de caracteres conteniendo el
|
||||
* nombre del manejador por defecto anterior <cPreviousDefaultRDD>.
|
||||
* $DESCRIPTION$
|
||||
* RDDSETDEFAULT() es una funci¢n que devuelve el nombre del manejador
|
||||
* (driver) por defecto anterior <cPreviousDefaultRDD> y opcionalmente
|
||||
* establece el manejador actual, especificado por <cNewDefaultRDD>.
|
||||
*
|
||||
* Si <cNewDefaultRDD> no es especificado, el nombre del manejador por
|
||||
* defecto actual es devuelto y ‚ste contin£a siendo el manejador por
|
||||
* defecto. El manejador por defecto es el driver que Harbour usa si Ud.
|
||||
* no especifica expl¡citamente un RDD con la cl usula VIA en el comando
|
||||
* USE.
|
||||
*
|
||||
* Esta funci¢n reemplaza a la funci¢n DBSETDRIVER()
|
||||
* $EXAMPLES$
|
||||
* // Si el manejador por defecto no es DBFNTX, ponerlo por defecto
|
||||
*
|
||||
* IF ( RDDSETDEFAULT() != "DBFNTX" )
|
||||
* cOldRdd := RDDSETDEFAULT( "DBFNTX" )
|
||||
* ENDIF
|
||||
* $TESTS$
|
||||
*
|
||||
* $STATUS$
|
||||
* R
|
||||
* $COMPLIANCE$
|
||||
*
|
||||
* $SEEALSO$
|
||||
* DBSETDRIVER()
|
||||
* $INCLUDE$
|
||||
*
|
||||
* $END$
|
||||
*/
|
||||
|
||||
|
||||
/* $DOC$
|
||||
* $FUNCNAME$
|
||||
* __RDDSETDEFAULT()
|
||||
* $CATEGORY$
|
||||
* Base de Datos
|
||||
* $ONELINER$
|
||||
* Establece ¢ retorna el RDD por defecto para la aplicaci¢n.
|
||||
* $SYNTAX$
|
||||
* __RDDSETDEFAULT( [<cNewDefaultRDD>] ) --> cPreviousDefaultRDD
|
||||
* $ARGUMENTS$
|
||||
* <cNewDefaultRDD> es una cadena de caracteres, el nombre del RDD que
|
||||
* va a ser hecho el nuevo RDD por defecto para la
|
||||
* aplicaci¢n.
|
||||
* $RETURNS$
|
||||
* __RDDSETDEFAULT() retorna una cadena de caracteres conteniendo el
|
||||
* nombre del manejador por defecto anterior <cPreviousDefaultRDD>.
|
||||
* $DESCRIPTION$
|
||||
* __RDDSETDEFAULT() es una funci¢n que devuelve el nombre del manejador
|
||||
* (driver) por defecto anterior <cPreviousDefaultRDD> y opcionalmente
|
||||
* establece el manejador actual, especificado por <cNewDefaultRDD>.
|
||||
*
|
||||
* Si <cNewDefaultRDD> no es especificado, el nombre del manejador por
|
||||
* defecto actual es devuelto y ‚ste contin£a siendo el manejador por
|
||||
* defecto. El manejador por defecto es el driver que Harbour usa si Ud.
|
||||
* no especifica expl¡citamente un RDD con la cl usula VIA en el comando
|
||||
* USE.
|
||||
* Esta es una funci¢n de bajo nivel y debe usarse RDDSETDEFAULT() en su
|
||||
* lugar.
|
||||
* Esta funci¢n reemplaza a la funci¢n DBSETDRIVER()
|
||||
* $EXAMPLES$
|
||||
* // Si el manejador por defecto no es DBFNTX, ponerlo por defecto
|
||||
*
|
||||
* IF ( __RDDSETDEFAULT() != "DBFNTX" )
|
||||
* cOldRdd := __RDDSETDEFAULT( "DBFNTX" )
|
||||
* ENDIF
|
||||
* $TESTS$
|
||||
*
|
||||
* $STATUS$
|
||||
* R
|
||||
* $COMPLIANCE$
|
||||
*
|
||||
* $SEEALSO$
|
||||
* DBSETDRIVER()
|
||||
* $INCLUDE$
|
||||
*
|
||||
* $END$
|
||||
*/
|
||||
|
||||
|
||||
|
||||
230
harbour/doc/es/sayget.txt
Normal file
230
harbour/doc/es/sayget.txt
Normal file
@@ -0,0 +1,230 @@
|
||||
/*
|
||||
* $Id$
|
||||
*/
|
||||
|
||||
/*
|
||||
* Las siguientes partes son derechos adquiridos de sus autores individuales.
|
||||
* www - http://www.harbour-project.org
|
||||
*
|
||||
* Copyright 2003 Alejandro de G rate <alex_degarate@hotmail.com>
|
||||
* Documentaci¢n en Espa¤ol de:
|
||||
* @...GET, @...SAY
|
||||
*
|
||||
* Vea doc/license.txt por los t‚rminos de la licencia.
|
||||
*
|
||||
*/
|
||||
|
||||
/* $DOC$
|
||||
* $COMMANDNAME$
|
||||
* @...GET
|
||||
* $CATEGORY$
|
||||
* Comando
|
||||
* $ONELINER$
|
||||
* Crea un objeto GET y lo visualiza en pantalla
|
||||
* $SYNTAX$
|
||||
* @ <nFila>,<nCol> [SAY <cSay> [PICTURE <cSayPict>] COLOR <cSayColor> ]
|
||||
* GET <xVar> [PICTURE <cGetPict>] [COLOR <cGetColor>]
|
||||
* [WHEN <lWhen>] [VALID <lValid> / RANGE <xInicio>,<xFin>]
|
||||
* $ARGUMENTS$
|
||||
* <nFila> La fila donde se visualiza el SAY/GET
|
||||
*
|
||||
* <nCol> La columna donde se visualiza el SAY/GET
|
||||
*
|
||||
* <cSay> Mensaje a visualizar
|
||||
*
|
||||
* <cSayPict> Expresi¢n de Caracteres para el PICTURE del SAY
|
||||
*
|
||||
* <cSayColor> Color a ser Usado por la expresi¢n SAY.
|
||||
*
|
||||
* <xVar> El nombre de la variable/campo
|
||||
*
|
||||
* <cGetPict> Expresi¢n de Caracteres para el PICTURE del GET
|
||||
*
|
||||
* <lWhen> Expresi¢n l¢gica para permitir el GET.
|
||||
*
|
||||
* <lValida> Expresi¢n l¢gica para validar la entrada del GET
|
||||
*
|
||||
* <xInicio> Valor inferior de RANGE
|
||||
*
|
||||
* <xFin> Valor superior de RANGE.
|
||||
*
|
||||
* <cGetColor> Cadena de Color a ser usada por la expresi¢n GET
|
||||
* $RETURNS$
|
||||
* Ninguno
|
||||
* $DESCRIPTION$
|
||||
* Este comando agrega un objeto GET al array p£blico reservado llamado
|
||||
* GETLIST[] y lo muestra en pantalla. El campo ¢ variable a ser
|
||||
* agregada al objeto GET es especificada en <xVar> y es visualizada
|
||||
* en las coordenadas fila, columna <nFila>, <nCol>.
|
||||
*
|
||||
* Si la cl usula SAY es usada el mensaje <cSay> ser visualizado
|
||||
* comenzando en <nFila>,<nCol>, mientras que la variable de campo
|
||||
* <xVar> ser visualizada en ROW(), COL()+ 1.
|
||||
*
|
||||
* Si la cl usula PICTURE es usada para la expresi¢n SAY, el molde
|
||||
* <cSayPicr> es usado, todas las reglas de formato contenidas en ‚l se
|
||||
* aplicar n. Vea la funci¢n TRANSFORM I, para mayor informaci¢n.
|
||||
*
|
||||
* Si <cGetPict> es especificado, la cl usula PICTURE de <xVar> ser
|
||||
* usada para el objeto GET y todas las reglas de formato ser n
|
||||
* aplicadas. Vea las reglas de formato para GET en la tabla m s abajo.
|
||||
*
|
||||
* Si la cl usula WHEN es especificada, entonces <lWhen> se eval£a por
|
||||
* una condici¢n l¢gica (.T.) y en ese caso el objeto GET ser activado
|
||||
* De otro modo el objeto GET ser saltado y ninguna informaci¢n ser
|
||||
* obtenida a trav‚s de la pantalla. El nombre de una funci¢n definida
|
||||
* por el usuario que retorne true (.T.) ¢ false ( F.) ¢ un codeblock
|
||||
* puede ser especificado en <lWhen>. Esta cl usula no ser activada
|
||||
* hasta que un comando READ ¢ una funci¢n READMODAL() sea ejecutada.
|
||||
*
|
||||
* Si la cl usula VALID es especificada, <lValida> se eval£a por una
|
||||
* condici¢n l¢gica (.T.), si se cumple, el GET actual se considera
|
||||
* v lido y la operatoria del GET continuar hasta encontrar el pr¢ximo
|
||||
* objeto GET activo. De lo contrario el cursor permanecer en este
|
||||
* objeto GET hasta que la operaci¢n se aborte ¢ la condici¢n en
|
||||
* <lValid> se cumpla (.T.). El nombre de una funci¢n definida por
|
||||
* el usuario que retorne true (.T.) ¢ false ( F.) ¢ un codeblock
|
||||
* puede ser especificado en <lValida>. Esta cl usula no ser activada
|
||||
* hasta que un comando READ ¢ una funci¢n READMODAL() sea ejecutada.
|
||||
*
|
||||
* Si la cl usula RANGE (rango) es especificada, en lugar de la cl usula
|
||||
* VALID, los dos valores que limitan el rango deben ser especificados
|
||||
* en <xInicio> y <xFin>. La variable que se eval£a debe ser del mismo
|
||||
* tipo que las que constituyen el rango. Si la variable <xVar> es del
|
||||
* tipo de fecha (DATE), <xInicio> y <xFin> deben ser tambi‚n del tipo
|
||||
* DATE. Si la variable <xVar> es del tipo NUMERICo <xInicio> y <xFin>
|
||||
* deben ser tambi‚n del tipo num‚rico. Si un valor falla el test RANGE,
|
||||
* un mensaje de "OUT OF RANGE" (fuera de rango) aparecer en el area
|
||||
* SCOREBOARD (fila = 0, col. = 60). El mensaje de RANGE puede ser
|
||||
* desactivado si el comando SET SCOREBOARD ¢ la funcion SET() apropiada
|
||||
* es puesta a .F.
|
||||
*
|
||||
* <fixed>
|
||||
* <table>
|
||||
* Funci¢n Reglas de Formateo del GET
|
||||
* @A Permite solamente caracteres alfab‚ticos
|
||||
* @B Los n£meros ser n justificados a la izquierda
|
||||
* @C Todos los n£meros positivos ser n seguidos por CR
|
||||
* @D Todas las fechas usar n el formato SET DATE
|
||||
* @E Las fechas estar n en formato Brit nico y los n£meros
|
||||
* en formato Europeo.
|
||||
* @K Permite que un valor sugerido sea visto dentro del GET
|
||||
* pero borrado si se presiona alguna tecla que no sea la
|
||||
* de cursores cuando el cursor esta en la primera posici¢n
|
||||
* en el rea del GET.
|
||||
* @R Los caracteres que se indican ser n insertados
|
||||
* @S<nSize> Permite el desplazamiento horizontal de un campo ¢
|
||||
* variable que es de <nSize> caracteres de ancho.
|
||||
* @X Todos los n£meros negativos ser n seguidos por DB
|
||||
* @Z Visualiza los valores num‚ricos cero como blancos
|
||||
* @! Fuerza la conversi¢n a may£sculas de los caracteres
|
||||
* @( Visualiza los n£meros negativos en parentesis con
|
||||
* espacios adelante
|
||||
* @) Visualiza los n£meros negativos en parentesis sin
|
||||
* espacios adelante
|
||||
* </table>
|
||||
* </fixed>
|
||||
*
|
||||
* <fixed>
|
||||
* <table>
|
||||
* Molde Reglas de Formateo del GET
|
||||
* A S¢lo caracteres alfab‚ticos son permitidos
|
||||
* N S¢lo caracteres alfab‚ticos y num‚ricos son permitidos
|
||||
* X Cualquier caracter es permitido
|
||||
* L S¢lo T ¢ F son permitidos para datos l¢gicos
|
||||
* Y S¢lo Y ¢ N son permitidos para datos l¢gicos
|
||||
* 9 S¢lo digitos, incluyendo signos ser n permitidos
|
||||
* # S¢lo digitos, signos y espacios ser n permitidos
|
||||
* ! Caracteres alfab‚ticos son convertidos a May£sculas
|
||||
* S El signo Pesos ser visualizado en lugar de espacios, delante
|
||||
* del tipo de dato num‚rico (aqui visto cmo una "S")
|
||||
* * El signo Asterisco ser visualizado en lugar de espacios
|
||||
* delante del tipo de dato num‚rico
|
||||
* . Punto, define la posici¢n del punto decimal
|
||||
* , Coma, define la posici¢n del separado de miles.
|
||||
* </table>
|
||||
* </fixed>
|
||||
* Nota:
|
||||
* Las funciones de formateo para PICTURE pueden ser agrupadas juntas
|
||||
* cuando sean usandas conjuntamente con los moldes para PICTURE.
|
||||
* Sin embargo un espacio en blanco debe ser insertado en la cadena de
|
||||
* PICTURE si existen ambas: funciones y moldes.
|
||||
* $EXAMPLES$
|
||||
* FUNCTION Main()
|
||||
* LOCAL cVar := Space(50)
|
||||
* LOCAL nId := 0
|
||||
* CLS
|
||||
* @ 3,1 SAY "Nombre" GET cVar PICTURE "@!S 30"
|
||||
* @ 4,1 SAY "Ident." GET nId PICTURE "999.999"
|
||||
* READ
|
||||
* ? "El nombre que Ud. ingres¢ es:", cVar
|
||||
* ? "La Ident. que Ud. ingres¢ es:", nId
|
||||
* RETURN NIL
|
||||
* $TESTS$
|
||||
* Ver ejemplos
|
||||
* $STATUS$
|
||||
* R
|
||||
* $COMPLIANCE$
|
||||
* Este comando es totalmente compatible con CA-Clipper.
|
||||
* $PLATFORMS$
|
||||
* Todas
|
||||
* $FILES$
|
||||
* La librer¡a asociada es rtl
|
||||
* $SEEALSO$
|
||||
* @...SAY,READ,TRANSFORM()
|
||||
* $END$
|
||||
*/
|
||||
|
||||
/* $DOC$
|
||||
* $COMMANDNAME$
|
||||
* @...SAY
|
||||
* $CATEGORY$
|
||||
* Comando
|
||||
* $ONELINER$
|
||||
* Visualiza datos en las coordenadas dadas en el dispositivo actual
|
||||
* $SYNTAX$
|
||||
* @ <nFila>,<nCol> SAY <xValor> [ PICTURE <cPict> ] [COLOR <cColor>]
|
||||
* $ARGUMENTS$
|
||||
* <nFila> La fila donde se visualiza el SAY
|
||||
*
|
||||
* <nCol> La columna donde se visualiza el SAY
|
||||
*
|
||||
* <xValor> Valor a visualizar
|
||||
*
|
||||
* <cPict> Formato para el PICTURE
|
||||
*
|
||||
* <cColor> Cadena de Color
|
||||
* $RETURNS$
|
||||
* Ninguno
|
||||
* $DESCRIPTION$
|
||||
* Este comando visualiza el contenido de <xValor> en las coordenadas
|
||||
* <nFila>, <nCol>. Una cl usula PICTURE puede ser especificada en
|
||||
* <cPict>. Si el dispositivo actual es establecido a la impresora, la
|
||||
* salida ir a la impresora; Por defecto todas las salidas son
|
||||
* dirigidas a la pantalla.
|
||||
*
|
||||
* Para una lista completa de los Moldes y Funciones para PICTURES, vea
|
||||
* el comando @...GET
|
||||
* $EXAMPLES$
|
||||
* FUNCTION Main
|
||||
* CLS
|
||||
* @ 2,1 SAY "Harbour"
|
||||
* @ 3,1 SAY "is" COLOR "b/r+"
|
||||
* @ 4,1 SAY "Power" PICTURE "@!"
|
||||
* RETURN NIL
|
||||
* $TESTS$
|
||||
* Ver ejemplos
|
||||
* $STATUS$
|
||||
* R
|
||||
* $COMPLIANCE$
|
||||
* Este comando es totalmente compatible con CA-Clipper.
|
||||
* $PLATFORMS$
|
||||
* Todas
|
||||
* $FILES$
|
||||
* La librer¡a asociada es rtl
|
||||
* $SEEALSO$
|
||||
* @...GET,SET DEVICE,TRANSFORM()
|
||||
* $END$
|
||||
*/
|
||||
|
||||
|
||||
1385
harbour/doc/es/subcodes.txt
Normal file
1385
harbour/doc/es/subcodes.txt
Normal file
File diff suppressed because it is too large
Load Diff
374
harbour/doc/es/tbrowse.txt
Normal file
374
harbour/doc/es/tbrowse.txt
Normal file
@@ -0,0 +1,374 @@
|
||||
/*
|
||||
* $Id$
|
||||
*/
|
||||
|
||||
/*
|
||||
* Las siguientes partes son derechos adquiridos de sus autores individuales.
|
||||
* www - http://www.harbour-project.org
|
||||
*
|
||||
* Copyright 2002 Alejandro de G rate <alex_degarate@hotmail.com>
|
||||
* Documentaci¢n en Espa¤ol de:
|
||||
* TBrowseNew()
|
||||
*
|
||||
* Vea doc/license.txt por los t‚rminos de la licencia.
|
||||
*
|
||||
*/
|
||||
|
||||
/* $CLASSDOC$
|
||||
* $FUNCNAME$
|
||||
* TBrowseNew()
|
||||
* $CATEGORY$
|
||||
* Clase TBrowse
|
||||
* $ONELINER$
|
||||
* Crea un Objeto Browse
|
||||
* $CONSTRUCTOR$
|
||||
* TBrowseNew( <nArriba>,<nIzq>,<nAbajo>,<nDerecha> ) --> <oBrowse>
|
||||
* $ARGUMENTS$
|
||||
* <nArriba> Fila Superior
|
||||
*
|
||||
* <nIzq> Columna Superior Izquierda
|
||||
*
|
||||
* <nAbajo> Fila Inferior
|
||||
*
|
||||
* <nDerecha> Columna Inferior Derecha
|
||||
* $RETURNS$
|
||||
* <oBrowse> Un nuevo Objeto Browse
|
||||
* $DESCRIPTION$
|
||||
* Esta función establece una ventana de desplazamiento en las
|
||||
* coordenadas establecidas por <nArriba>, <nIzq>, <nAbajo>, <nDerecha>
|
||||
* Para visualizar una base de datos use la función TBrowseDB() en
|
||||
* su lugar.
|
||||
* $DATANOLINK$
|
||||
* :aColumns Array para guardar todas las columnas del browse
|
||||
*
|
||||
* :autoLite Valor Lógico para controlar el color brillante
|
||||
*
|
||||
* :cargo Variable definida por el usuario
|
||||
*
|
||||
* :colorSpec Tabla de Color para la visualización del TBrowse
|
||||
*
|
||||
* :colPos Columna de posición actual del cursor
|
||||
*
|
||||
* :colSep Caracter separador de Columnas
|
||||
*
|
||||
* :footSep Caracter separador de Notas al pie
|
||||
*
|
||||
* :freeze Número de columnas a Congelar
|
||||
*
|
||||
* :goBottomBlock Codeblock ejecutado por TBrowse:goBottom()
|
||||
*
|
||||
* :goTopBlock Codeblock ejecutado por TBrowse:goTop()
|
||||
*
|
||||
* :headSep Caracter separador de Encabezados
|
||||
*
|
||||
* :hitBottom Indica el fin de los datos disponibles
|
||||
*
|
||||
* :hitTop Indica el comienzo de los datos disponibles
|
||||
*
|
||||
* :leftVisible Indica la posición de la columna no congelada
|
||||
* más a la izquierda en la pantalla
|
||||
*
|
||||
* :nBottom Número de la Fila Inferior para la visualización
|
||||
* del objeto TBrowse
|
||||
*
|
||||
* :nLeft Columna más a la Izquierda para la visualización
|
||||
* del objeto TBrowse
|
||||
*
|
||||
* :nRight Columna más a la Derecha para la visualización
|
||||
* del objeto TBrowse
|
||||
*
|
||||
* :nTop Número de la Fila Superior para la visualización
|
||||
* del objeto TBrowse
|
||||
*
|
||||
* :rightVisible Indica la posición de la columna no congelada
|
||||
* más a la Derecha en la pantalla
|
||||
*
|
||||
* :rowCount Número de filas de datos visibles en el TBrowse
|
||||
*
|
||||
* :rowPos Fila de posición actual del cursor
|
||||
*
|
||||
* :skipBlock Codeblock usado para la reposicion de datos
|
||||
*
|
||||
* :stable Indica si el objeto TBrowse es estable
|
||||
*
|
||||
* :aRedraw Array de items lógicos indicando si es apropiado
|
||||
* cuales filas necesitan ser redibujadas
|
||||
*
|
||||
* :RelativePos Indica la posición del registro relativa a la
|
||||
* posición del primer registro en la pantalla
|
||||
*
|
||||
* :lHeaders Variable interna que indica cuando hay cabeceras
|
||||
* de columnas para dibujar
|
||||
*
|
||||
* :lFooters Variable interna que indica cuando hay pie de
|
||||
* columnas para dibujar
|
||||
*
|
||||
* :aRect El rectangulo especificado con ColorRect()
|
||||
*
|
||||
* :aRectColor Los colores para usar en el rectangulo especificado
|
||||
* con ColorRect()
|
||||
*
|
||||
* :aKeys Mantiene las teclas de movimiento por defecto
|
||||
*
|
||||
* $METHODSLINK$
|
||||
* AddColumn() Agrega un nuevo objeto TBColumn al Browse actual
|
||||
*
|
||||
* Applykey() Ejecuta el movimiento de teclas del Browse
|
||||
*
|
||||
* SetKey() Agrega una nueva tecla al diccionario de teclado
|
||||
* $METHODSNOLINK$
|
||||
* New(nTop, nLeft, nBottom, nRight)
|
||||
* Crea una nueva clase Browse y establece los
|
||||
* valores por defecto
|
||||
*
|
||||
* Down() Mueve el cursor una fila hacia abajo
|
||||
*
|
||||
* End() Mueve el cursor a la columna de datos más hacia
|
||||
* la derecha que esté visible.
|
||||
*
|
||||
* GoBottom() Reposiciona los datos fuentes al final del archivo
|
||||
*
|
||||
* GoTop() Reposiciona los datos fuentes al inicio del
|
||||
* archivo
|
||||
*
|
||||
* Home() Mueve el cursor a la columna visible más hacia la
|
||||
* izquierda
|
||||
*
|
||||
* Left() Mueve el cursor una columna hacia la izquierda
|
||||
*
|
||||
* PageDown() Reposiciona los datos fuentes hacia abajo
|
||||
*
|
||||
* PageUp() Reposiciona los datos fuentes hacia arriba
|
||||
*
|
||||
* PanEnd() Mueve el cursor a la columna de datos más a la
|
||||
* derecha
|
||||
*
|
||||
* PanHome() Mueve el cursor a la columna de datos más a la
|
||||
* izquierda
|
||||
*
|
||||
* PanLeft() Se desplaza hacia la izquierda sin cambiar la
|
||||
* posición del cursor
|
||||
*
|
||||
* PanRight() Se desplaza hacia la derecha sin cambiar la
|
||||
* posición del cursor
|
||||
*
|
||||
* Right() Mueve el cursor una columna hacia la derecha
|
||||
*
|
||||
* Up() Mueve el cursor una fila hacia arriba
|
||||
*
|
||||
* ColCount() Retorna el número actual de columnas
|
||||
*
|
||||
* ColorRect() Altera el color de un grupo rectangular de celdas
|
||||
*
|
||||
* ColWidth(nCol) Retorna el ancho de visualización de una columna
|
||||
* particular
|
||||
*
|
||||
* Configure( nMode) Reconfigura los seteos internos del objeto
|
||||
* TBrowse. <nMode> es un parámetro no
|
||||
* documentado en CA-Cl*pper
|
||||
*
|
||||
* LeftDetermine() Determina la columna no congelada más a la
|
||||
* izquierda en la pantalla
|
||||
*
|
||||
* DeHilite() Saca el color brillante a la celda actual
|
||||
*
|
||||
* DelColumn( nPos ) Borra un objeto Column de un Browse
|
||||
*
|
||||
* ForceStable() Ejecuta una estabilización total
|
||||
*
|
||||
* GetColumn( nColumn ) Obtiene un objeto TBColumn específico
|
||||
*
|
||||
* Hilite() Resalta la celda actual
|
||||
*
|
||||
* InsColumn( nPos, oCol) Inserta un objeto TBColumn de un Browse
|
||||
*
|
||||
* Invalidate() Fuerza un redibujo completo durante la
|
||||
* próxima estabilización
|
||||
*
|
||||
* RefreshAll() Causa que todos los datos sean recalculados
|
||||
* durante la próxima estabilización
|
||||
*
|
||||
* RefreshCurrent() Causa que la fila actual sea rellenada y
|
||||
* redibujada en la próxima estabilización
|
||||
*
|
||||
* SetColumn( nColumn, oCol) Reemplaza un objeto TBColumn con otro
|
||||
*
|
||||
* Stabilize() Ejecuta una estabilización incremental
|
||||
*
|
||||
* DispCell( nCol, cColor) Visualiza una sola celda en el color dado
|
||||
*
|
||||
* $EXAMPLES$
|
||||
* Vea el archivo ../tests/testbrw.prg
|
||||
* $TESTS$
|
||||
* Vea el archivo ../tests/testbrw.prg
|
||||
* $STATUS$
|
||||
* S
|
||||
* $COMPLIANCE$
|
||||
* Estas funciones son compatibles con CA-Clipper 5.2
|
||||
* Los métodos Applykey() y Setkey() solamente son visibles si la
|
||||
* compatibilidad con Clipper 5.3 ( HB_COMPAT_C53 ) está definida.
|
||||
* $PLATFORMS$
|
||||
* Todas
|
||||
* $FILES$
|
||||
* La librería asociada es rtl
|
||||
* $SEEALSO$
|
||||
* TBROWSENEW(),TBCOLUMNNEW()
|
||||
* $END$
|
||||
*/
|
||||
|
||||
|
||||
/* $CLASSDOC$
|
||||
* $METHOD$
|
||||
* SetKey()
|
||||
* $CATEGORY$
|
||||
* TBrowse Method
|
||||
* $ONELINER$
|
||||
* Obtiene y/o Establece un bloque de código asociado a una tecla
|
||||
* $SYNTAX$
|
||||
* SetKey( <nTecla> [,<bBlock>] ) --> bOldBlock
|
||||
* $ARGUMENTS$
|
||||
* <nTecla> Un código de tecla (inkey) válido
|
||||
*
|
||||
* <bBlock> Una ación opcional a asociar con el valor de la tecla
|
||||
* $RETURNS$
|
||||
* <bOldBlock> Si al presionar una tecla, se cambia el codeblock
|
||||
* se devolverá el bloque previo, de otro modo este
|
||||
* método devolverá el codeblock actual.
|
||||
* $DESCRIPTION$
|
||||
* Este método Obtiene y opcionalmente Establece un bloque de código
|
||||
* que es asociado con el valor de una tecla.
|
||||
* La tabla inferior muestra las definiciones de teclas/codeblocks
|
||||
*
|
||||
* <table>
|
||||
* Valor Tecla Bloque de Código
|
||||
*
|
||||
* K_DOWN {|Ob, nKey| Ob:Down(), 0}
|
||||
* K_END {|Ob, nKey| Ob:End(), 0}
|
||||
* K_CTRL_PGDN {|Ob, nKey| Ob:GoBottom(), 0}
|
||||
* K_CTRL_PGUP {|Ob, nKey| Ob:GoTop(), 0}
|
||||
* K_HOME {|Ob, nKey| Ob:Home(), 0}
|
||||
* K_LEFT {|Ob, nKey| Ob:Left(), 0}
|
||||
* K_PGDN {|Ob, nKey| Ob:PageDown(), 0}
|
||||
* K_PGUP {|Ob, nKey| Ob:PageUp(), 0}
|
||||
* K_CTRL_END {|Ob, nKey| Ob:PanEnd(), 0}
|
||||
* K_CTRL_HOME {|Ob, nKey| Ob:PanHome(), 0}
|
||||
* K_CTRL_LEFT {|Ob, nKey| Ob:PanLeft(), 0}
|
||||
* K_CTRL_RIGHT {|Ob, nKey| Ob:PanRight(),0}
|
||||
* K_RIGHT {|Ob, nKey| Ob:Right(), 0}
|
||||
* K_UP {|Ob, nKey| Ob:Up(), 0}
|
||||
* K_ESC {|Ob, nKey| -1 }
|
||||
* </table>
|
||||
*
|
||||
* Los manejadores de tecla pueden ser consultados, agregados,
|
||||
* reemplazados y removidos del dicccionario interno de teclado.
|
||||
* Por ejemplo
|
||||
*
|
||||
* oTb:SETKEY( K_TAB, {|oTb, nKey| -1} )
|
||||
*
|
||||
* Un manejador de teclas por defecto, puede ser declarado al
|
||||
* especificar un valor de cero para <nKey>. esto asocia el codeblock
|
||||
* que será evaluado cada vez que TBrowse:Applykey() sea llamado con
|
||||
* un valor de tecla que no este contenida en el diccionario.
|
||||
* Por ejemplo
|
||||
*
|
||||
* oTb:SetKey( 0, {|oTb, nKey| DefKeyHandler( otb, nkey) })
|
||||
* Esto llama a una función llamada DefKeyHandler() cuando nKey no
|
||||
* está contenida en el diccionario.
|
||||
*
|
||||
* Para remover una definición presion de tecla/codeblock, especifique
|
||||
* NIl para <bBlock>
|
||||
* oTb:SetKey( K_ESC, NIL )
|
||||
* $EXAMPLES$
|
||||
* oTb:SeyKey( K_F10, {|otb,nkey| ShowListByname(otb) }
|
||||
* $STATUS$
|
||||
* S
|
||||
* $COMPLIANCE$
|
||||
* El método Setkey() solamente es visible si la compatibilidad con
|
||||
* Clipper 5.3 ( HB_COMPAT_C53 ) está definida.
|
||||
* $PLATFORMS$
|
||||
* Todas
|
||||
* $FILES$
|
||||
* La librería asociada es rtl
|
||||
* $SEEALSO$
|
||||
* Applykey()
|
||||
* $END$
|
||||
*/
|
||||
|
||||
/* $CLASSDOC$
|
||||
* $METHOD$
|
||||
* Applykey()
|
||||
* $CATEGORY$
|
||||
* TBrowse Method
|
||||
* $ONELINER$
|
||||
* Evalúa un codeblock asociado con una tecla especifica
|
||||
* $SYNTAX$
|
||||
* ApplyKey( <nTecla> ) --> nResultado
|
||||
* $ARGUMENTS$
|
||||
* <nTecla> Un código de tecla (inkey) válido
|
||||
* $RETURNS$
|
||||
* <nResultado> Valor devuelto para el codeblock evaluado
|
||||
* Ver Tabla abajo
|
||||
*
|
||||
* <table>
|
||||
* Valor Significado
|
||||
* -1 El usuario solicita que el browse pierda foco de entrada
|
||||
* 0 El codeblock asociado con <nTecla> fue evaluado
|
||||
* 1 Imposible de localizar <nTecla> en el diccionario, la tecla
|
||||
* no fué procesada
|
||||
* </table>
|
||||
* $DESCRIPTION$
|
||||
* Este método evalúa un bloque de código asociado con <nTecla> que
|
||||
* está contenida en el diccionario TBrowse:setkey()
|
||||
* $EXAMPLES$
|
||||
* WHILE .T.
|
||||
* oTb:forceStable()
|
||||
*
|
||||
* IF( oTb:applykey( inkey(0) ) == -1 )
|
||||
* EXIT
|
||||
* ENDIF
|
||||
*
|
||||
* ENDDO
|
||||
* $STATUS$
|
||||
* S
|
||||
* $COMPLIANCE$
|
||||
* El método Applykey() solamente es visible si la compatibilidad con
|
||||
* Clipper 5.3 ( HB_COMPAT_C53 ) está definida.
|
||||
* $PLATFORMS$
|
||||
* Todas
|
||||
* $FILES$
|
||||
* La librería asociada es rtl
|
||||
* $SEEALSO$
|
||||
* SetKey()
|
||||
* $END$
|
||||
*/
|
||||
|
||||
/* $CLASSDOC$
|
||||
* $METHOD$
|
||||
* AddColumn()
|
||||
* $CATEGORY$
|
||||
* TBrowse Method
|
||||
* $ONELINER$
|
||||
* Agrega una nueva Column a un Objeto TBrowse
|
||||
* $SYNTAX$
|
||||
* AddColumn( oCol ) --> Self
|
||||
* $ARGUMENTS$
|
||||
* <oCol> Es un Objeto TBColumn
|
||||
* $RETURNS$
|
||||
* <Self> El Objeto actual
|
||||
* $DESCRIPTION$
|
||||
* Este método agrega un nuevo Objeto TBColumn especificado como <oCol>
|
||||
* al objeto de browsing asignado.
|
||||
* $STATUS$
|
||||
* R
|
||||
* $COMPLIANCE$
|
||||
* Esta función es compatible con CA-Clipper 5.2
|
||||
* $PLATFORMS$
|
||||
* Todas
|
||||
* $FILES$
|
||||
* La librería asociada es rtl
|
||||
* $SEEALSO$
|
||||
* TBColumnNew()
|
||||
* $END$
|
||||
*/
|
||||
|
||||
|
||||
76
harbour/doc/es/tclass.txt
Normal file
76
harbour/doc/es/tclass.txt
Normal file
@@ -0,0 +1,76 @@
|
||||
/*
|
||||
* $Id$
|
||||
*/
|
||||
|
||||
/*
|
||||
* Las siguientes partes son derechos adquiridos de sus autores individuales.
|
||||
* www - http://www.harbour-project.org
|
||||
*
|
||||
* Copyright 2000 Alejandro de G rate <alex_degarate@hotmail.com>
|
||||
* Documentaci¢n en Espa¤ol de:
|
||||
*
|
||||
* Copyright 2000 Brian Hays <bhays@abacuslaw.com>
|
||||
* Documentaci¢n en Ingles
|
||||
*
|
||||
* Vea doc/license.txt por los t‚rminos de la licencia.
|
||||
*
|
||||
*/
|
||||
|
||||
/* $DOC$
|
||||
* $FUNCNAME$
|
||||
* HBClass()
|
||||
* $CATEGORY$
|
||||
* Clases
|
||||
* $ONELINER$
|
||||
* HBClass() es usada en la creaci¢n de todas las clases
|
||||
* $SYNTAX$
|
||||
* oClass := HBClass():New("TMyClass")
|
||||
*
|
||||
* HBClass() es usualmente utilizada para definir una clase con los
|
||||
* comandos definidos en hbclass.h:
|
||||
* CLASS HBGetList // Llama a HBClass() para crear la clase
|
||||
* ... // HBGetList
|
||||
* ENDCLASS
|
||||
* $ARGUMENTS$
|
||||
*
|
||||
* $RETURNS$
|
||||
* Una instancia de la Clase HBClass. Un objeto especial, el m‚todo
|
||||
* :New() puede entonces crear las clases que Ud. define.
|
||||
* $DESCRIPTION$
|
||||
* HBClass es una clase que ...
|
||||
* Los m‚todos de clase son los siguientes:
|
||||
*
|
||||
* New() Crea una nueva instancia de la clase
|
||||
*
|
||||
* $EXAMPLES$
|
||||
* FUNCTION TestObject()
|
||||
* LOCAL oObject
|
||||
*
|
||||
* oObject := HBClass():New("TMyClass")
|
||||
* oObject:End()
|
||||
*
|
||||
* RETURN NIL
|
||||
* </fixed>
|
||||
* $STATUS$
|
||||
* R
|
||||
* $COMPLIANCE$
|
||||
* La sintaxis Orientada a Objetos en Harbour es compatible con
|
||||
* CA-CLIPPER.
|
||||
* Pero Clipper solamente permite la creaci¢n de objetos a partir
|
||||
* de unas pocas clases estandares, y NO le permite al programador
|
||||
* crear nuevas clases.
|
||||
* En Harbour, Ud. puede crear sus propias clases completamente con
|
||||
* M‚todos, Variables de Instancia, Variables de Clase y Herencia.
|
||||
* Aplicaciones enteras pueden ser designadas y codificadas en el
|
||||
* estilo Orientado a Objetos.
|
||||
* $PLATFORMS$
|
||||
* Todas
|
||||
* $FILES$
|
||||
* La librer¡a es rtl
|
||||
* $SEEALSO$
|
||||
* __objHasData(),Programacion Orientada a Objeto,CLASS
|
||||
* $END$
|
||||
*/
|
||||
|
||||
|
||||
|
||||
74
harbour/doc/es/tgetlist.txt
Normal file
74
harbour/doc/es/tgetlist.txt
Normal file
@@ -0,0 +1,74 @@
|
||||
/*
|
||||
* $Id$
|
||||
*/
|
||||
|
||||
/*
|
||||
* Las siguientes partes son derechos adquiridos de sus autores individuales.
|
||||
* www - http://www.harbour-project.org
|
||||
*
|
||||
* Copyright 2002 Alejandro de G rate <alex_degarate@hotmail.com>
|
||||
* Documentaci¢n en Espa¤ol de:
|
||||
*
|
||||
* Copyright 1999 Chen Kedem <niki@actcom.co.il>
|
||||
* Documentaci¢n en Ingl‚s de: READVAR()
|
||||
*
|
||||
* Vea doc/license.txt por los t‚rminos de la licencia.
|
||||
*
|
||||
*/
|
||||
|
||||
/* $DOC$
|
||||
* $FUNCNAME$
|
||||
* READVAR()
|
||||
* $CATEGORY$
|
||||
* Data input and output
|
||||
* $ONELINER$
|
||||
* Retorna el nombre de la variable del actual GET ¢ MENU
|
||||
* $SYNTAX$
|
||||
* READVAR( [<cNombreVar>] ) --> cViejoNombreVar
|
||||
* $ARGUMENTS$
|
||||
* <cNombreVar> es el nuevo nombre de la variable a establecer
|
||||
* $RETURNS$
|
||||
* READVAR() retorna el viejo nombre de la variable <cViejoNombreVar>.
|
||||
* Si ninguna variable fue establecida anteriormente, READVAR() retorna
|
||||
* una cadena vac¡a.
|
||||
* $DESCRIPTION$
|
||||
* READVAR() es establecida dentro del comando READ ¢ MENU TO para
|
||||
* mantener el nombre en may£sculas de la variable del GET / MENU TO
|
||||
* actual y volverla de nuevo al viejo valor cuando aquellos comandos
|
||||
* finalizan.
|
||||
* Ud. no deber¡a normalmente establecer un nombre de variable, sino
|
||||
* usarlo para obtener el nombre de la variable de un GET cuando se
|
||||
* ejecuta una clausula VALID ¢ WHEN. ¢ durante la ejecuci¢n de un
|
||||
* SET KEY y Ud. esta dentro de un READ ¢ MENU TO.
|
||||
* $EXAMPLES$
|
||||
* // Visualiza un menu, presione <F1> para ver el nombre de la
|
||||
* // variable de MENU TO
|
||||
* CLS
|
||||
* @ 1, 10 PROMPT "insecto chupador de sangre que infecta camas"
|
||||
* @ 2, 10 PROMPT "germen; infeccion viral "
|
||||
* @ 3, 10 PROMPT "defecto; snag; (fuente de) malfuncionamiento"
|
||||
* @ 4, 10 PROMPT "peque¤o microfono oculto "
|
||||
* @ 6, 10 SAY "(Presione F1 por una pista)"
|
||||
* SET KEY 28 TO ShowVar
|
||||
* MENU TO What_Is_Bug
|
||||
*
|
||||
* PROCEDURE ShowVar
|
||||
* ALERT( READVAR() ) // WHAT_IS_BUG in red ALERT() box
|
||||
* RETURN
|
||||
* </fixed>
|
||||
* $STATUS$
|
||||
* R
|
||||
* $COMPLIANCE$
|
||||
* READVAR() trabaja exactamente como la funci¢n READKEY() de Clipper.
|
||||
* Note sin embargo que el par metro <cVarName> no est documentado
|
||||
* y es usado internamente por CA-Clipper.
|
||||
* $PLATFORMS$
|
||||
* Todas
|
||||
* $FILES$
|
||||
* La Librer¡a es rtl
|
||||
* $SEEALSO$
|
||||
* @...GET,@...PROMPT,MENU TO,READ,SET KEY,__AtPrompt(),__MenuTo()
|
||||
* $END$
|
||||
*/
|
||||
|
||||
|
||||
100
harbour/doc/es/tlabel.txt
Normal file
100
harbour/doc/es/tlabel.txt
Normal file
@@ -0,0 +1,100 @@
|
||||
/*
|
||||
* $Id$
|
||||
*/
|
||||
|
||||
/*
|
||||
* Las siguientes partes son derechos adquiridos de sus autores individuales.
|
||||
* www - http://www.harbour-project.org
|
||||
*
|
||||
* Copyright 2002 Alejandro de G rate <alex_degarate@hotmail.com>
|
||||
* Documentaci¢n en Espa¤ol de: LABEL FORM
|
||||
*
|
||||
* Copyright 1999 Luiz Rafael Culik <culik@sl.conex.net>
|
||||
* Documentacion en Ingl‚s
|
||||
*
|
||||
* Vea doc/license.txt por los t‚rminos de la licencia.
|
||||
*
|
||||
*/
|
||||
|
||||
/* $DOC$
|
||||
* $FUNCNAME$
|
||||
* LABEL FORM
|
||||
* $CATEGORY$
|
||||
* Comando
|
||||
* $ONELINER$
|
||||
* Visualiza etiquetas en la pantalla ¢ en alg£n dispositivo alterno
|
||||
* $SYNTAX$
|
||||
* LABEL FORM <cNombreEtiqueta> [TO PRINTER] [TO FILE <cArchivo>]
|
||||
* [<cAlcance>] [WHILE <bWhile> ] [FOR <bFor> ]
|
||||
* [SAMPLE] [NOCONSOLE]
|
||||
* $ARGUMENTS$
|
||||
* <cNombreEtiqueta> Nombre del archivo de etiquetas
|
||||
*
|
||||
* <cArchivo> Nombre de un archivo alterno
|
||||
*
|
||||
* <cAlcance> Expresi¢n de una condici¢n de ambito ¢ alcance
|
||||
*
|
||||
* <bWhile> Expresi¢n l¢gica de una Condici¢n WHILE
|
||||
*
|
||||
* <bFor> Expresi¢n l¢gica de una Condici¢n FOR
|
||||
* $DESCRIPTION$
|
||||
* Este comando permite imprimir etiquetas basadas en el formato
|
||||
* establecido en el archivo LBL, a un archivo especificado en
|
||||
* <cNombreEtiqueta>.
|
||||
* Por defecto la salida ir a la pantalla, sin embargo esta salida
|
||||
* puede ser redirigida ¢ bien a la impresora usando la cl usula
|
||||
* TO PRINTER, ¢ bien a un archivo usando la cl usula TO FILE.
|
||||
*
|
||||
* Si la cl usula TO FILE es especificada, el nombre del archivo de
|
||||
* texto ASCII conteniendo las etiquetas generadas ser <cArchivo>.
|
||||
*
|
||||
* Si ninguna extensi¢n de archivo es especificada, la extensi¢n .TXT
|
||||
* es agregada.
|
||||
*
|
||||
* <cAlcance> es la condici¢n de alcance para este comando. Alcances
|
||||
* v lidos incluyen:
|
||||
* NEXT <expN> (n£mero de registros a ser visualizados donde <expN>
|
||||
* es el n£mero de registros)
|
||||
* RECORD <expN> (un registro espec¡fico a ser impreso)
|
||||
* REST (todos los registros comenzando desde la posici¢n del registro
|
||||
* actual.
|
||||
* ALL (todos los registros)
|
||||
* Por defecto es ALL (todo).
|
||||
*
|
||||
* Ambas expresiones l¢gicas pueden trabajar en conjunci¢n con la otra
|
||||
* Donde <bFor> es la expresi¢n l¢gica para la condici¢n FOR (para los
|
||||
* registros a ser visualizados dentro de un rango dado).
|
||||
* <bWhile> es la expresi¢n l¢gica para la condici¢n WHILE (para los
|
||||
* registros a ser visualizados hasta que se deje de cumplir la
|
||||
* condici¢n.
|
||||
*
|
||||
* Si la cl usula SAMPLE es especificada, etiquetas de prueba ser n
|
||||
* generadas.
|
||||
*
|
||||
* Si la cl usula NOCONSOLE es especificada, la salida a la consola ser
|
||||
* desactivada mientras este comando este siendo ejecutado.
|
||||
*
|
||||
* Este comando sigue el criterio de ambito establecido en el comando
|
||||
* SET PATH TO. El camino puede ser especifficado junto con la letra
|
||||
* del disco en <cNombreEtiqueta>.
|
||||
* $EXAMPLES$
|
||||
* FUNCTION MAIN()
|
||||
* USE Test New
|
||||
* LABEL FORM EE
|
||||
* USE
|
||||
* RETURN NIL
|
||||
*
|
||||
* $STATUS$
|
||||
* R
|
||||
* $COMPLIANCE$
|
||||
* Este comando es totalmente compatible con CA-Clipper.
|
||||
* $PLATFORMS$
|
||||
* Todas
|
||||
* $FILES$
|
||||
* La librer¡a es rtl
|
||||
* $SEEALSO$
|
||||
* REPORT FORM
|
||||
* $END$
|
||||
*/
|
||||
|
||||
|
||||
126
harbour/doc/es/treport.txt
Normal file
126
harbour/doc/es/treport.txt
Normal file
@@ -0,0 +1,126 @@
|
||||
/*
|
||||
* $Id$
|
||||
*/
|
||||
|
||||
/*
|
||||
* Las siguientes partes son derechos adquiridos de sus autores individuales.
|
||||
* www - http://www.harbour-project.org
|
||||
*
|
||||
* Copyright 2002 Alejandro de G rate <alex_degarate@hotmail.com>
|
||||
* Documentaci¢n en Espa¤ol de:
|
||||
* REPORT FORM
|
||||
*
|
||||
* Copyright 1999 Luiz Rafael Culik <culik@sl.conex.net>
|
||||
* Documentacion
|
||||
*
|
||||
* Vea doc/license.txt por los t‚rminos de la licencia.
|
||||
*
|
||||
*/
|
||||
|
||||
/* $DOC$
|
||||
* $FUNCNAME$
|
||||
* REPORT FORM
|
||||
* $CATEGORY$
|
||||
* Comando
|
||||
* $ONELINER$
|
||||
* Visualiza un reporte
|
||||
* $SYNTAX$
|
||||
* REPORT FORM <cNombreReporte> [TO PRINTER] [TO FILE <cArchivo>]
|
||||
* [<cAlcance>] [WHILE <bWhile> ] [FOR <bFor> ]
|
||||
* [PLAIN |HEADING <cEncabezado>] [NOEJECT] [SUMMARY]
|
||||
* [NOCONSOLE]
|
||||
* $ARGUMENTS$
|
||||
* <cNombreReporte> Nombre del archivo de reporte
|
||||
*
|
||||
* <cArchivo> Nombre de un archivo alterno
|
||||
*
|
||||
* <cAlcance> Ambito ¢ alcance
|
||||
*
|
||||
* <bWhile> Expresi¢n l¢gica de una Condici¢n WHILE
|
||||
*
|
||||
* <bFor> Expresi¢n l¢gica de una Condici¢n FOR
|
||||
*
|
||||
* <cEncabezado> Encabezado del Reporte
|
||||
* $RETURNS$
|
||||
* NIL
|
||||
* $DESCRIPTION$
|
||||
* Este comando imprime un informe ¢ reporte llamado <cNombreReporte>,
|
||||
* el cual es un archivo estandar FRM. La extensi¢n del archivo no es
|
||||
* necesaria porque la extensi¢n .FRM es asumida por defecto.
|
||||
* Los comandos SET PATH TO y SET DEFAULT TO afectan la b£squeda del
|
||||
* archivo <cNombreReporte>; a menos que la unidad de disco y el path
|
||||
* sean especificados en <cNombreReporte>, REPORT buscar dentro del
|
||||
* path especificado en el comando SET PATH y si no puede encontrar
|
||||
* el modelo de reporte en el directorio actual.
|
||||
*
|
||||
* La salida del reporte ser desplazada basada en el valor de
|
||||
* SET MARGIN TO.
|
||||
*
|
||||
* Por defecto la salida ir a la pantalla, sin embargo esta salida
|
||||
* puede ser redirigida ¢ bien a la impresora usando la cl usula
|
||||
* TO PRINTER, ¢ bien a un archivo usando la cl usula TO FILE.
|
||||
*
|
||||
* Si la cl usula TO FILE es especificada, el nombre de un archivo
|
||||
* alterno es especificado en <cArchivo>.
|
||||
* Si ninguna extensi¢n de archivo es especificada, la extensi¢n .TXT
|
||||
* es agregada.
|
||||
*
|
||||
* <cAlcance> es la condici¢n de alcance para este comando. Alcances
|
||||
* v lidos incluyen:
|
||||
* NEXT <expN> (n£mero de registros a ser visualizados donde <expN>
|
||||
* es el n£mero de registros)
|
||||
* RECORD <expN> (un registro espec¡fico a ser impreso)
|
||||
* REST (todos los registros comenzando desde la posici¢n del registro
|
||||
* actual.
|
||||
* ALL (todos los registros)
|
||||
* Por defecto es ALL (todo).
|
||||
*
|
||||
* Ambas expresiones l¢gicas pueden trabajar en conjunci¢n con la otra
|
||||
* Donde <bFor> es la expresi¢n l¢gica para la condici¢n FOR (para
|
||||
* registros a ser visualizados dentro de un rango dado).
|
||||
* <bWhile> es la expresi¢n l¢gica para la condici¢n WHILE (para los
|
||||
* registros a ser visualizados hasta que se deje de cumplir la
|
||||
* condici¢n.
|
||||
*
|
||||
* Si la cl usula PLAIN es especificada, la fecha y los n£meros de
|
||||
* pagina son suprimidos. En adicion no hay salto autom tico de p gina
|
||||
* y el t¡tulo del reporte y los encabezados de columna aparecen una
|
||||
* sola vez al principio del reporte.
|
||||
*
|
||||
* Si la cl usula HEADING es usada, <cEncabezado> es visualizado en el
|
||||
* t¡tulo de cada p gina del reporte. El valor de <cEncabezado> es
|
||||
* evaluado solamente una vez antes de la ejecuci¢n del reporte; variar
|
||||
* los valores de <cEncabezado> no est permitido. La cl usula PLAIN
|
||||
* tiene precedencia sobre la cl usula HEADING si ambas son incluidas.
|
||||
*
|
||||
* Si la cl usula NOEJECT es usada, la eyecci¢n de la p gina inicial
|
||||
* en el reporte no ser realizado cuando la cl usula TO PRINTER sea
|
||||
* especificada.
|
||||
* De otro modo esta cl usula no tendr efecto.
|
||||
*
|
||||
* Si la cl usula SUMMARY es especificada, el reporte contendr
|
||||
* solamente grupos, subgrupos e informaci¢n de totales. La informaci¢n
|
||||
* detallada del elemento t¡tulo ser ignorada.
|
||||
*
|
||||
* Si la cl usula NOCONSOLE es especificada, la salida a la consola serÿ
|
||||
* desactivada mientras este comando este siendo ejecutado.
|
||||
* $EXAMPLES$
|
||||
* FUNCTION() MAIN
|
||||
* USE Test New
|
||||
* Report FORM EE
|
||||
* USE
|
||||
* RETURN NIL
|
||||
* $STATUS$
|
||||
* R
|
||||
* $COMPLIANCE$
|
||||
* Este comando es totalmente compatible con CA-Clipper.
|
||||
* $PLATFORMS$
|
||||
* Todas
|
||||
* $FILES$
|
||||
* La librera es rtl
|
||||
* $SEEALSO$
|
||||
* LABEL FORM
|
||||
* $END$
|
||||
*/
|
||||
|
||||
|
||||
920
harbour/doc/es/var.txt
Normal file
920
harbour/doc/es/var.txt
Normal file
@@ -0,0 +1,920 @@
|
||||
/*
|
||||
* $Id$
|
||||
*/
|
||||
|
||||
/*
|
||||
* Las siguientes partes son derechos adquiridos de sus autores individuales.
|
||||
* www - http://www.harbour-project.org
|
||||
*
|
||||
* Copyright 2003 Alejandro de G rate <alex_degarate@hotmail.com>
|
||||
* Documentaci¢n en Espa¤ol de:
|
||||
* __MVPUBLIC(), __MVPRIVATE(), __MVXRELEASE(),
|
||||
* __MVRELEASE(), __MVSCOPE(), __MVCLEAR(),
|
||||
* __MVDBGINFO(), __MVEXIST(), __MVGET(), __MVPUT(), MEMVARBLOCK(),
|
||||
* FIELDBLOCK(), FIELDWBLOCK(), TYPE(), VALTYPE(), HB_ISBYREF()
|
||||
*
|
||||
* Copyright 1999 Ryszard Glab <rglab@imid.med.pl>
|
||||
* Documentaci¢n en Ingl‚s de:
|
||||
* __MVPUBLIC(), __MVPRIVATE(), __MVXRELEASE(),
|
||||
* __MVRELEASE(), __MVSCOPE(), __MVCLEAR(),
|
||||
* __MVDBGINFO(), __MVGET(), __MVPUT(), MEMVARBLOCK(),
|
||||
* TYPE()
|
||||
*
|
||||
* Copyright 1999 Chen Kedem <niki@actcom.co.il>
|
||||
* Documentaci¢n en Ingl‚s de: FIELDBLOCK(), FIELDWBLOCK()
|
||||
*
|
||||
* Copyright 2001 Chen Kedem <niki@actcom.co.il>
|
||||
* Documentaci¢n en Ingl‚s de: __MVEXIST()
|
||||
*
|
||||
* Copyright 2002 Walter Negro <anegro@overnet.com.ar>
|
||||
* Documentaci¢n en Ingl‚s de: HB_ISBYREF()
|
||||
*
|
||||
* Vea doc/license.txt por los t‚rminos de la licencia.
|
||||
*
|
||||
*/
|
||||
|
||||
/* $DOC$
|
||||
* $FUNCNAME$
|
||||
* __MVPUBLIC()
|
||||
* $CATEGORY$
|
||||
* Variable Management
|
||||
* $ONELINER$
|
||||
* Esta funci¢n crea una variable PUBLIC
|
||||
* $SYNTAX$
|
||||
* __MVPUBLIC( <xNombrevariable> )
|
||||
* $ARGUMENTS$
|
||||
* <xNombrevariable> Es ¢ bien una cadena que contiene el nombre de la
|
||||
* variable ¢ un array unidimensional de cadenas con
|
||||
* nombres de variables.
|
||||
* Los esqueletos ¢ comodines no estan permitidos.
|
||||
* $RETURNS$
|
||||
* Nada
|
||||
* $DESCRIPTION$
|
||||
* Esta funci¢n puede ser llamada por el compilador Harbour ¢ bien por
|
||||
* el usuario.
|
||||
* El compilador siempre pasa un item de tipo IT_SYMBOL que almacena el
|
||||
* nombre de la variable.
|
||||
* Si una variable con el mismo nombre ya existe, entonces la nueva
|
||||
* variable no es creada, el valor previo permanece sin cambios.
|
||||
* Si esta es la primera variable con ese nombre, entonces la variable
|
||||
* es inicializada con el valor .T.
|
||||
* $EXAMPLES$
|
||||
* Ninguno disponible
|
||||
* $STATUS$
|
||||
* R
|
||||
* $COMPLIANCE$
|
||||
* Esta funci¢n es una extensi¢n de Harbour.
|
||||
* $FILES$
|
||||
* La librer¡a asociada es vm
|
||||
* $SEEALSO$
|
||||
* __MVPRIVATE(),__MVXRELEASE()
|
||||
* $END$
|
||||
*/
|
||||
|
||||
/* $DOC$
|
||||
* $FUNCNAME$
|
||||
* __MVPRIVATE()
|
||||
* $CATEGORY$
|
||||
* Variable Management
|
||||
* $ONELINER$
|
||||
* Esta funci¢n crea una variable PRIVATE
|
||||
* $SYNTAX$
|
||||
* __MVPRIVATE( <xNombrevariable> )
|
||||
* $ARGUMENTS$
|
||||
* <xNombrevariable> Es ¢ bien una cadena que contiene el nombre de la
|
||||
* variable ¢ un array unidimensional de cadenas con
|
||||
* nombres de variables.
|
||||
* Los esqueletos ¢ comodines no estan permitidos.
|
||||
* $RETURNS$
|
||||
* Nada
|
||||
* $DESCRIPTION$
|
||||
* Esta funci¢n puede ser llamada por el compilador Harbour ¢ bien por
|
||||
* el usuario.
|
||||
* El compilador siempre pasa un item de tipo IT_SYMBOL que almacena el
|
||||
* nombre de la variable.
|
||||
* Si una variable con el mismo nombre ya existe, entonces el valor de
|
||||
* la vieja variable es ocultado hasta que la nueva variable sea
|
||||
* liberada.
|
||||
* La nueva variable es siempre inicializada con el valor NIL.
|
||||
* $EXAMPLES$
|
||||
* Ninguno disponible
|
||||
* $STATUS$
|
||||
* R
|
||||
* $COMPLIANCE$
|
||||
* Esta funci¢n es una extensi¢n de Harbour.
|
||||
* $FILES$
|
||||
* La librer¡a asociada es vm
|
||||
* $SEEALSO$
|
||||
* __MVPUBLIC(),__MVRELEASE(),__MVXRELEASE()
|
||||
* $END$
|
||||
*/
|
||||
|
||||
/* $DOC$
|
||||
* $FUNCNAME$
|
||||
* __MVXRELEASE()
|
||||
* $CATEGORY$
|
||||
* Variable Management
|
||||
* $ONELINER$
|
||||
* Libera un valor almacenado en una variable PRIVATE or PUBLIC
|
||||
* $SYNTAX$
|
||||
* __MVXRELEASE( <xNombrevariable> )
|
||||
* $ARGUMENTS$
|
||||
* <xNombrevariable> Es ¢ bien una cadena que contiene el nombre de la
|
||||
* variable ¢ un array unidimensional de cadenas con
|
||||
* nombres de variables.
|
||||
* Los esqueletos ¢ comodines no estan permitidos.
|
||||
* $RETURNS$
|
||||
* Nada
|
||||
* $DESCRIPTION$
|
||||
* Esta funci¢n libera valores almacenados en variable de memoria. Esta
|
||||
* NO DEBE ser llamada directamente, sino que debe ser puesta dentro
|
||||
* del comando RELEASE.
|
||||
* Si la variable liberada es una variable PRIVATE entonces la variable
|
||||
* previamente ocultada con el mismo nombre se vuelve visible despu‚s
|
||||
* de salir del procedimiento donde la variable liberada fu‚ creada.
|
||||
* Si Ud. accede la variable liberada en el mismo procedimiento/funci¢n
|
||||
* donde esta fu‚ creada el valor NIL es devuelto. Ud. puede sin embargo
|
||||
* asignar un nuevo valor a la variable liberada sin ning£n efecto
|
||||
* colateral.
|
||||
*
|
||||
* Esto libera la variable, a£n si esta variable fue creada en un
|
||||
* procedimiento diferente.
|
||||
* $EXAMPLES$
|
||||
*
|
||||
* PROCEDURE MAIN()
|
||||
* PRIVATE mPrivate
|
||||
* mPrivate :="PRIVATE from MAIN()"
|
||||
* ? mPrivate //PRIVATE from MAIN()
|
||||
* Test()
|
||||
* ? mPrivate //PRIVATE from MAIN()
|
||||
* RETURN
|
||||
*
|
||||
*
|
||||
* PROCEDURE Test()
|
||||
* PRIVATE mPrivate
|
||||
* mPrivate :="PRIVATE from Test()"
|
||||
* ? mPrivate //PRIVATE from TEST()
|
||||
* RELEASE mPrivate
|
||||
* ? mPrivate //NIL
|
||||
* mPrivate :="Again in Test()"
|
||||
* RETURN
|
||||
* </fixed>
|
||||
* $STATUS$
|
||||
* R
|
||||
* $COMPLIANCE$
|
||||
* Esta funci¢n es una extensi¢n de Harbour.
|
||||
* $FILES$
|
||||
* La librer¡a asociada es vm
|
||||
* $SEEALSO$
|
||||
* __MVPRIVATE(),__MVPUBLIC()
|
||||
* $END$
|
||||
*/
|
||||
|
||||
/* $DOC$
|
||||
* $FUNCNAME$
|
||||
* __MVRELEASE()
|
||||
* $CATEGORY$
|
||||
* Variable Management
|
||||
* $ONELINER$
|
||||
* Esta funci¢n libera variables PRIVATE
|
||||
* $SYNTAX$
|
||||
* __MVRELEASE( <cMascara>, <lIncludeExclude_flag> )
|
||||
* $ARGUMENTS$
|
||||
* <cMascara> Cadena que contiene la m scara comod¡n para los nombres
|
||||
* de variables que ser n liberadas. Los comodines
|
||||
* soportados son: '*' y '?'
|
||||
*
|
||||
* <lIncludeExclude_flag> Valor l¢gico que esecifica si las variables
|
||||
* que coinciden con la m scara debieran ser borradas (.T.)
|
||||
* ¢ excluidas del borrado si es .F.
|
||||
* $RETURNS$
|
||||
* Nada
|
||||
* $DESCRIPTION$
|
||||
* Esta funci¢n libera valores almacenados en variable de memoria. Esta
|
||||
* NO DEBE ser llamada directamente, sino que debe ser puesta dentro
|
||||
* del comando RELEASE ALL.
|
||||
* Si la variable liberada es una variable PRIVATE entonces la variable
|
||||
* previamente ocultada con el mismo nombre se vuelve visible despu‚s
|
||||
* de salir del procedimiento donde la variable liberada fu‚ creada.
|
||||
* Si Ud. accede la variable liberada en el mismo procedimiento/funci¢n
|
||||
* donde esta fu‚ creada el valor NIL es devuelto. Ud. puede sin embargo
|
||||
* asignar un nuevo valor a la variable liberada sin ning£n efecto
|
||||
* colateral.
|
||||
* Variables PUBLIC no son cambiadas por esta funci¢n.
|
||||
* $EXAMPLES$
|
||||
* Ninguno
|
||||
* $STATUS$
|
||||
* R
|
||||
* $COMPLIANCE$
|
||||
* Esta funci¢n es una extensi¢n de Harbour.
|
||||
* $FILES$
|
||||
* La librer¡a asociada es vm
|
||||
* $SEEALSO$
|
||||
* __MVPRIVATE()
|
||||
* $END$
|
||||
*/
|
||||
|
||||
/* $DOC$
|
||||
* $FUNCNAME$
|
||||
* __MVSCOPE()
|
||||
* $CATEGORY$
|
||||
* Variable Management
|
||||
* $ONELINER$
|
||||
* Si la variable existe, entonces retorna su alcance
|
||||
* $SYNTAX$
|
||||
* __MVSCOPE( <cNombreVar> )
|
||||
* $ARGUMENTS$
|
||||
* <cNombreVar> Una cadena con el nombre de una variable a chequear
|
||||
* $RETURNS$
|
||||
* Los valores simb¢licos son definidos en ../include/hbmemvar.ch
|
||||
*
|
||||
* <table>
|
||||
* Macro Significado
|
||||
*
|
||||
* HB_MV_NOT_FOUND La variable no est declarada (no fu‚ encontrada
|
||||
* en la tabla de s¡mbolos)
|
||||
* HB_MV_UNKNOWN Si la variable No existe (pero fu‚ encontrada
|
||||
* en la tabla de s¡mbolos)
|
||||
* HB_MV_ERROR Si la informaci¢n No puede ser obtenida (error
|
||||
* de memoria ¢ error de argumento).
|
||||
* HB_MV_PUBLIC para variables p£blicas
|
||||
* HB_MV_PRIVATE_GLOBAL para variables private declaradas fuera del
|
||||
* actual FUNCTION/PROCEDURE
|
||||
* HB_MV_PRIVATE_LOCAL para variables private declaradas dentro del
|
||||
* actual FUNCTION/PROCEDURE
|
||||
* </table>
|
||||
* </fixed>
|
||||
* $EXAMPLES$
|
||||
*
|
||||
* PROCEDURE MAIN()
|
||||
* PUBLIC mPublic
|
||||
* PRIVATE mPrivateGlobal
|
||||
*
|
||||
* CallProc()
|
||||
* ? __mvScope( "mPrivateLocal" ) // HB_MV_UNKNOWN
|
||||
* RETURN
|
||||
*
|
||||
*
|
||||
* PROCEDURE CallProc()
|
||||
* PRIVATE mPrivateLocal
|
||||
*
|
||||
* ? __mvScope( "mPublic" ) // HB_MV_PUBLIC
|
||||
* ? __mvScope( "mPrivateGlobal" ) // HB_MV_PRIVATE_GLOBAL
|
||||
* ? __mvScope( "mPrivateLocal" ) // HB_MV_PRIVATE_LOCAL
|
||||
* ? __mvScope( "mFindMe" ) // HB_MV_NOT_FOUND
|
||||
*
|
||||
* IF( __mvScope( "mPublic" ) > HB_MV_ERROR )
|
||||
* ? "la Variable existe"
|
||||
* ELSE
|
||||
* ? "la Variable no fu‚ creada a£n"
|
||||
* ENDIF
|
||||
*
|
||||
* RETURN
|
||||
* </fixed>
|
||||
* $STATUS$
|
||||
* R
|
||||
* $COMPLIANCE$
|
||||
* Esta funci¢n es una extensi¢n de Harbour.
|
||||
* $FILES$
|
||||
* El archivo de cabecera es ../include/hbmemvar.ch
|
||||
* La librer¡a asociada es vm
|
||||
* $SEEALSO$
|
||||
* __MVPRIVATE(),__MVPUBLIC()
|
||||
* $END$
|
||||
*/
|
||||
|
||||
/* $DOC$
|
||||
* $FUNCNAME$
|
||||
* __MVCLEAR()
|
||||
* $CATEGORY$
|
||||
* Variable Management
|
||||
* $ONELINER$
|
||||
* Borra todas las variables PRIVATE y PUBLIC
|
||||
* $SYNTAX$
|
||||
* __MVCLEAR()
|
||||
* $ARGUMENTS$
|
||||
* Ninguno
|
||||
* $RETURNS$
|
||||
* Nada
|
||||
* $DESCRIPTION$
|
||||
* Esta funci¢n borra todas las variables PRIVATE y PUBLIC.
|
||||
* Esta es usada para implementar la sentencia CLEAR MEMORY.
|
||||
* La memoria ocupada por todas las variables es liberada.
|
||||
* Cualquier intento de acceder a la variable resultar en un error
|
||||
* de ejecuci¢n.
|
||||
* Ud tiene que reusar la sentencia PRIVATE ¢ PUBLIC para crear de nuevo
|
||||
* la variable que fue borrada por esta funci¢n.
|
||||
* $STATUS$
|
||||
* R
|
||||
* $COMPLIANCE$
|
||||
* Esta funci¢n es una extensi¢n de Harbour.
|
||||
* $FILES$
|
||||
* La librer¡a asociada es vm
|
||||
* $SEEALSO$
|
||||
* __MVPRIVATE(),__MVPUBLIC()
|
||||
* $END$
|
||||
*/
|
||||
|
||||
/* $DOC$
|
||||
* $FUNCNAME$
|
||||
* __MVDBGINFO()
|
||||
* $CATEGORY$
|
||||
* Variable Management
|
||||
* $ONELINER$
|
||||
* Retorna informaci¢n sobre las variables para el debugger
|
||||
* $SYNTAX$
|
||||
* __MVDBGINFO( <nAlcance> [, <nPosicion> [, @<cNombreVar>] ] )
|
||||
* $ARGUMENTS$
|
||||
* <nAlcance> El alcance de las variables sobre las que la informaci¢n
|
||||
* es solicitada.
|
||||
* Valores Soportados (definidos en hbmemvar.ch):
|
||||
* HB_MV_PUBLIC
|
||||
* HB_MV_PRIVATE (or any other value)
|
||||
*
|
||||
* <nPosicion> La posici¢n de la variable solicitada en la lista de
|
||||
* variables con el alcance especificado. Esta deberia
|
||||
* comenzar desde la posici¢n 1
|
||||
*
|
||||
* <cNombreVar> El valor es llenado con un nombre de variable si es
|
||||
* pasada por referencia y <nPosicion> es especificada
|
||||
* $RETURNS$
|
||||
* El valor retornado depende del n£mero de par metros pasados
|
||||
* $DESCRIPTION$
|
||||
* Esta funci¢n obtiene informaci¢n acerca de las variables memvar.
|
||||
* Esta devuelve ¢ bien el n£merode variables con un alcance dado
|
||||
* (Cuando el primer argumento es pasado solamente) ¢ un valor de
|
||||
* variable identificada por su posici¢n en la la lista de variables
|
||||
* (Cuando el segundo argumento es pasado).
|
||||
* Esta tambi‚n devuelve el nombre de la variable si el tercer argumento
|
||||
* opcional es pasado por referencia.
|
||||
*
|
||||
* Si la variable solicitada no existe (la posici¢n solicitada es mayor
|
||||
* que el n£mero de variables definidas), entonces el valor NIL es
|
||||
* devuelto y el nombre de la variable es puesto a "?"
|
||||
*
|
||||
* Como la tabla din mica de s¡mbolos es usada para encontrar una
|
||||
* variable PUBLIC, las variables PUBLICas son siempre ordenadas
|
||||
* alfab‚ticamente. Las variables PRIVATE son ordenadas en el orden
|
||||
* de su creaci¢n.
|
||||
*
|
||||
* Nota:
|
||||
* Debido a la naturaleza din mica de las variables memvar no hay
|
||||
* garant¡a que sucesivas llamadas para recuperar el valor de la
|
||||
* variable PUBLIC <N> retornar el valor de la misma variable.
|
||||
* $EXAMPLES$
|
||||
* #include <hbmemvar.ch>
|
||||
*
|
||||
* LOCAL nCount, i, xValue, cName
|
||||
*
|
||||
* nCount =_mvDBGINFO( HB_MV_PUBLIC )
|
||||
*
|
||||
* FOR i:=1 TO nCount
|
||||
* xValue =__mvDBGINFO( HB_MV_PUBLIC, i, @cName )
|
||||
* ? i, cName, xValue
|
||||
* NEXT
|
||||
* </fixed>
|
||||
* $TESTS$
|
||||
* #include <hbmemvar.ch>
|
||||
* PROCEDURE MAIN()
|
||||
*
|
||||
* ? 'PUBLIC=', __mvDBGINFO( HB_MV_PUBLIC )
|
||||
* ? 'PRIVATE=', __mvDBGINFO( HB_MV_PRIVATE )
|
||||
*
|
||||
* PUBLIC cPublic:='cPublic in MAIN'
|
||||
*
|
||||
* ? 'PUBLIC=', __mvDBGINFO( HB_MV_PUBLIC )
|
||||
* ? 'PRIVATE=', __mvDBGINFO( HB_MV_PRIVATE )
|
||||
*
|
||||
* PRIVATE cPrivate:='cPrivate in MAIN'
|
||||
*
|
||||
* ? 'PUBLIC=', __mvDBGINFO( HB_MV_PUBLIC )
|
||||
* ? 'PRIVATE=', __mvDBGINFO( HB_MV_PRIVATE )
|
||||
*
|
||||
* CountMemvars()
|
||||
*
|
||||
* ? 'Back in Main'
|
||||
* ? 'PUBLIC=', __mvDBGINFO( HB_MV_PUBLIC )
|
||||
* ? 'PRIVATE=', __mvDBGINFO( HB_MV_PRIVATE )
|
||||
*
|
||||
* RETURN
|
||||
*
|
||||
*
|
||||
* PROCEDURE CountMemvars()
|
||||
* LOCAL i, nCnt, xVal, cName
|
||||
* PUBLIC ccPublic:='ccPublic'
|
||||
* PRIVATE ccPrivate:='ccPrivate'
|
||||
*
|
||||
* ? 'In CountMemvars'
|
||||
* ? 'PUBLIC=', __mvDBGINFO( HB_MV_PUBLIC )
|
||||
* ? 'PRIVATE=', __mvDBGINFO( HB_MV_PRIVATE )
|
||||
*
|
||||
* PRIVATE cPublic:='cPublic'
|
||||
*
|
||||
* ? 'PUBLIC=', __mvDBGINFO( HB_MV_PUBLIC )
|
||||
* ? 'PRIVATE=', __mvDBGINFO( HB_MV_PRIVATE )
|
||||
*
|
||||
* nCnt =__mvDBGINFO( HB_MV_PRIVATE ) +1
|
||||
*
|
||||
* FOR i :=1 TO nCnt
|
||||
* xVal =__mvDBGINFO( HB_MV_PRIVATE, i, @cName )
|
||||
* ? i, '=', cName, xVal
|
||||
* NEXT
|
||||
*
|
||||
* nCnt = __mvDBGINFO( HB_MV_PUBLIC ) + 1
|
||||
*
|
||||
* FOR i :=1 TO nCnt
|
||||
* xVal = __mvDBGINFO( HB_MV_PUBLIC, i, @cName )
|
||||
* ? i, '=', cName, xVal
|
||||
* NEXT
|
||||
*
|
||||
* RETURN
|
||||
* </fixed>
|
||||
* $STATUS$
|
||||
* R
|
||||
* $COMPLIANCE$
|
||||
* Esta funci¢n deber¡a ser llamada solamente desde el depurador.
|
||||
* $FILES$
|
||||
* La librer¡a asociada es vm
|
||||
* $SEEALSO$
|
||||
* __MVSCOPE()
|
||||
* $END$
|
||||
*/
|
||||
|
||||
/* $DOC$
|
||||
* $FUNCNAME$
|
||||
* __MVEXIST()
|
||||
* $CATEGORY$
|
||||
* Variable Management
|
||||
* $ONELINER$
|
||||
* Determina si un nombre dado es una variable PUBLIC ¢ PRIVATE
|
||||
* $SYNTAX$
|
||||
* __MVEXIST( <cNombreVar> ) --> <lExisteVar>
|
||||
* $ARGUMENTS$
|
||||
* <cNombreVar> Cadena con el nombre de la variable a chequear
|
||||
* $RETURNS$
|
||||
* __MVEXIST() retorna TRUE (.T.) si una MEMVAR llamada <cNombreVar>
|
||||
* existe actualmente.
|
||||
* $DESCRIPTION$
|
||||
* Esta funci¢n determina si una variable PUBLIC ¢ PRIVATE con el
|
||||
* nombre <cNombreVar> existe ¢ no.
|
||||
* $EXAMPLES$
|
||||
* LOCAL TheLocal
|
||||
* STATIC TheStatic
|
||||
* PUBLIC ThePublic
|
||||
* PRIVATE ThePrivate
|
||||
* ? __MVEXIST( "NotExist" ) // .F.
|
||||
* ? __MVEXIST( "TheLocal" ) // .F.
|
||||
* ? __MVEXIST( "TheStatic" ) // .F.
|
||||
* ? __MVEXIST( "ThePublic" ) // .T.
|
||||
* ? __MVEXIST( "ThePrivate" ) // .T.
|
||||
* </fixed>
|
||||
* $STATUS$
|
||||
* R
|
||||
* $COMPLIANCE$
|
||||
* Esta funci¢n es una extensi¢n de Harbour.
|
||||
* $FILES$
|
||||
* La librer¡a asociada es vm
|
||||
* $SEEALSO$
|
||||
* MEMVAR, PRIVATE, PUBLIC
|
||||
* $END$
|
||||
*/
|
||||
|
||||
/* $DOC$
|
||||
* $FUNCNAME$
|
||||
* __MVGET()
|
||||
* $CATEGORY$
|
||||
* Variable Management
|
||||
* $ONELINER$
|
||||
* Esta funci¢n retorna el valor de una variable de memoria (MEMVAR)
|
||||
* $SYNTAX$
|
||||
* __MVGET( <cNombreVar> ) --> <xVar>
|
||||
* $ARGUMENTS$
|
||||
* <cNombreVar> Cadena con el nombre de la variable
|
||||
* $RETURNS$
|
||||
* <xVar> el valor de la variable
|
||||
* $DESCRIPTION$
|
||||
* Esta funci¢n devuelve el valor de una variable de memoria PRIVATE ¢
|
||||
* PUBLIC si la variable existe, de otro modo genera un error en tiempo
|
||||
* de ejecuci¢n.
|
||||
* La variable es especificada por su nombre pasado como par metro a la
|
||||
* funci¢n.
|
||||
* $EXAMPLES$
|
||||
* FUNCTION MEMVARBLOCK( cMemvar )
|
||||
* RETURN {|x| IIF( PCOUNT()==0, __MVGET( cMemvar ),;
|
||||
* __MVPUT( cMemvar, x ) ) }
|
||||
* </fixed>
|
||||
* $STATUS$
|
||||
* R
|
||||
* $COMPLIANCE$
|
||||
* Esta funci¢n es una extensi¢n de Harbour.
|
||||
* $FILES$
|
||||
* La librer¡a asociada es vm
|
||||
* $SEEALSO$
|
||||
* __MVPUT()
|
||||
* $END$
|
||||
*/
|
||||
|
||||
/* $DOC$
|
||||
* $FUNCNAME$
|
||||
* __MVPUT()
|
||||
* $CATEGORY$
|
||||
* Variable Management
|
||||
* $ONELINER$
|
||||
* Esta funci¢n establece el valor de una variable de memoria
|
||||
* $SYNTAX$
|
||||
* __MVGET( <cNombreVar> [, <xValor>] ) --> <xValor>
|
||||
* $ARGUMENTS$
|
||||
* <cNombreVar> Cadena con el nombre de la variable
|
||||
*
|
||||
* <xValor> Un valor de cualquier tipo que puede ser establecido
|
||||
* Si no es especificado, entonces NIL es asumido.
|
||||
* $RETURNS$
|
||||
* <xValor> Un valor asignado a la variable dada.
|
||||
* $DESCRIPTION$
|
||||
* Esta funci¢n establece el valor de una variable de memoria PRIVATE ¢
|
||||
* PUBLIC si la variable existe, de otro modo genera un error en tiempo
|
||||
* de ejecuci¢n.
|
||||
* La variable es especificada por su nombre pasado como par metro a la
|
||||
* funci¢n.
|
||||
* Si un valor no es especificado, entonces NIL es asumido.
|
||||
* $EXAMPLES$
|
||||
* FUNCTION MEMVARBLOCK( cMemvar )
|
||||
* RETURN {|x| IIF( PCOUNT()==0, __MVGET( cMemvar ),;
|
||||
* __MVPUT( cMemvar, x ) ) }
|
||||
* </fixed>
|
||||
* $STATUS$
|
||||
* R
|
||||
* $COMPLIANCE$
|
||||
* Esta funci¢n es una extensi¢n de Harbour.
|
||||
* $FILES$
|
||||
* La librer¡a asociada es vm
|
||||
* $SEEALSO$
|
||||
* __MVPUT()
|
||||
* $END$
|
||||
*/
|
||||
|
||||
/* $DOC$
|
||||
* $FUNCNAME$
|
||||
* MEMVARBLOCK()
|
||||
* $CATEGORY$
|
||||
* Variable Management
|
||||
* $ONELINER$
|
||||
* Retorna un codeblock que establece/obtiene el valor de variable
|
||||
* $SYNTAX$
|
||||
* MEMVARBLOCK( <cNombreMemvar> ) --> <bBloque>
|
||||
* $ARGUMENTS$
|
||||
* <cNombreMemvar> Cadena con el nombre de la variable
|
||||
* $RETURNS$
|
||||
* <bBloque> un codeblock que establece/obtiene el valor de variable
|
||||
* $DESCRIPTION$
|
||||
* Esta funci¢n devuelve un codeblock que establece/obtiene el valor de
|
||||
* una variable PRIVATE ¢ PUBLIC. Cuando este codeblock es evaluado
|
||||
* sin ning£n par metro pasado, entonces este devuelve el valor actual
|
||||
* de la variable dada.
|
||||
* Si el segundo par metro es pasado para la evaluaci¢n del codeblock
|
||||
* entonces este valor es usado para establecer el nuevo valor de la
|
||||
* variable dada, el valor pasado es tambi‚n retornado como un valor
|
||||
* la evaluaci¢n del codeblock.
|
||||
* $EXAMPLES$
|
||||
* PROCEDURE MAIN()
|
||||
* LOCAL cbSetGet
|
||||
* PUBLIC xPublic
|
||||
*
|
||||
* cbSetGet = MEMVARBLOCK( "xPublic" )
|
||||
* EVAL( cbSetGet, "nuevo valor" )
|
||||
* ? "Valor de la variable xPublic:", EVAL( cbSetGet )
|
||||
*
|
||||
* RETURN
|
||||
* </fixed>
|
||||
* $STATUS$
|
||||
* R
|
||||
* $COMPLIANCE$
|
||||
* Esta funci¢n es compatible con CA-Clipper
|
||||
* $FILES$
|
||||
* La Librer¡a es rtl
|
||||
* $SEEALSO$
|
||||
* __MVGET(),__MVPUT()
|
||||
* $END$
|
||||
*/
|
||||
|
||||
/* $DOC$
|
||||
* $FUNCNAME$
|
||||
* FIELDBLOCK()
|
||||
* $CATEGORY$
|
||||
* Code Block
|
||||
* $ONELINER$
|
||||
* Retorna un codeblock que establece/obtiene el valor de un campo
|
||||
* $SYNTAX$
|
||||
* FIELDBLOCK( <cFieldName> ) --> bFieldBlock
|
||||
* $ARGUMENTS$
|
||||
* <cFieldName> Es una cadena que contiene el nombre de un campo.
|
||||
* $RETURNS$
|
||||
* FIELDBLOCK() retorna un codeblock que cuando es evaluado puede
|
||||
* obtener el valor del campo ¢ asignar un nuevo valor al campo.
|
||||
* Si <cFieldName> no es especificado ¢ es de otro tipo distinto a
|
||||
* CHARACTER, FIELDBLOCK() retorna NIL.
|
||||
* $DESCRIPTION$
|
||||
* FIELDBLOCK() retorna un codeblock que establece/obtiene el valor de
|
||||
* un campo.
|
||||
* Cuando este campo es evaluado sin ning£n par metro pasado entonces
|
||||
* este devuelve el valor actual del campo dado.
|
||||
* Si el codeblock es evaluado con un par metro, entonces su valor es
|
||||
* usado para establecer un nuevo valor para el campo, este valor es
|
||||
* tambi‚n retornado por el bloque.
|
||||
* Si el bloque es evaluado y no hay ning£n campo con el nombre
|
||||
* <cFieldName> en el rea actual de trabajo el codeblock devuelve NIL.
|
||||
*
|
||||
* Note que FIELDBLOCK() trabaja en el rea actual de trabajo, si Ud.
|
||||
* necesita usar un rea de trabajo distinta a la actual, use
|
||||
* FIELDWBLOCK() en su lugar.
|
||||
* $EXAMPLES$
|
||||
* // Abre un archivo llamado Test que tiene un campo llamado "name"
|
||||
* LOCAL bField
|
||||
* bFiled := FIELDBLOCK( "name" )
|
||||
* USE Test
|
||||
*
|
||||
* ? 'Valor Original del campo "name" :', EVAL( bField )
|
||||
* EVAL( bField, "Mr X new name" )
|
||||
* ? 'Nuevo valor para el campo "name" :', EVAL( bField )
|
||||
* </fixed>
|
||||
* $STATUS$
|
||||
* R
|
||||
* $COMPLIANCE$
|
||||
* Si el bloque es evaluado y no hay ning£n campo con el nombre
|
||||
* <cFieldName> en el rea actual de trabajo, el codeblock devuelve NIL.
|
||||
*
|
||||
* CA-Clipper produce un error BASE/1003 si el campo no existe.
|
||||
* $FILES$
|
||||
* La Librer¡a es rtl
|
||||
* $SEEALSO$
|
||||
* EVAL(),FIELDWBLOCK(),MEMVARBLOCK()
|
||||
* $END$
|
||||
*/
|
||||
|
||||
/* $DOC$
|
||||
* $FUNCNAME$
|
||||
* FIELDWBLOCK()
|
||||
* $CATEGORY$
|
||||
* Code Block
|
||||
* $ONELINER$
|
||||
* Retorna un codeblock que setea/obtiene un campo en una rea dada
|
||||
* $SYNTAX$
|
||||
* FIELDWBLOCK( <cFieldName>, <nWorkArea> ) --> bFieldBlock
|
||||
* $ARGUMENTS$
|
||||
* <cFieldName> Es una cadena que contiene el nombre de un campo.
|
||||
*
|
||||
* <nWorkArea> N£mero de rea de trabajo en la cual <cFieldName> existe
|
||||
*
|
||||
* $RETURNS$
|
||||
* FIELDWBLOCK() retorna un codeblock que cuando es evaluado puede
|
||||
* obtener el valor del campo ¢ asignar un nuevo valor al campo en un
|
||||
* rea de trabajo dada.
|
||||
* Si <cFieldName> no es especificado ¢ es de otro tipo distinto a
|
||||
* CHARACTER, ¢ si <nWorkArea> no es especificada ¢ no es NUMERICa
|
||||
* FIELDWBLOCK() retorna NIL.
|
||||
* $DESCRIPTION$
|
||||
* FIELDWBLOCK() retorna un codeblock que establece/obtiene el valor de
|
||||
* un campo para un rea de trabajo dada.
|
||||
* Cuando este campo es evaluado sin ning£n par metro pasado entonces
|
||||
* este devuelve el valor actual del campo dado.
|
||||
* Si el codeblock es evaluado con un par metro, entonces su valor es
|
||||
* usado para establecer un nuevo valor para el campo, este valor es
|
||||
* tambi‚n retornado por el bloque.
|
||||
* Si el bloque es evaluado y no hay ning£n campo con el nombre
|
||||
* <cFieldName> en el rea de trabajo especificada, el codeblock
|
||||
* devuelve NIL.
|
||||
* $EXAMPLES$
|
||||
* LOCAL bField
|
||||
* // Este bloque trabaja sobre campo "name" que existe en el area 2
|
||||
* bFiled := FIELDBLOCK( "name", 2 )
|
||||
*
|
||||
* // Abre el archivo llamado One en el area 1,
|
||||
* // que tiene un campo llamado "name"
|
||||
* SELECT 1
|
||||
* USE One
|
||||
*
|
||||
* // Abre el archivo llamado Two en el area 2,
|
||||
* // que tambien tiene un campo llamado "name"
|
||||
* SELECT 2
|
||||
* USE Two
|
||||
* SELECT 1
|
||||
* ? "Nombres Originales: ", One->name, Two->name
|
||||
* ? "Nombre para el archivo dos:", EVAL( bField )
|
||||
* EVAL( bField, "Two tiene un nuevo nombre" )
|
||||
* ? "y ahora: ", One->name, Two->name
|
||||
* </fixed>
|
||||
* $STATUS$
|
||||
* R
|
||||
* $COMPLIANCE$
|
||||
* Si el bloque es evaluado y no hay ning£n campo con el nombre
|
||||
* <cFieldName> en el rea de trabajo dada, el codeblock devuelve NIL.
|
||||
*
|
||||
* CA-Clipper produce un error BASE/1003 si el campo no existe.
|
||||
* $FILES$
|
||||
* La Librer¡a es rtl
|
||||
* $SEEALSO$
|
||||
* EVAL(),FIELDBLOCK(),MEMVARBLOCK()
|
||||
* $END$
|
||||
*/
|
||||
|
||||
/* $DOC$
|
||||
* $FUNCNAME$
|
||||
* TYPE()
|
||||
* $CATEGORY$
|
||||
* Miscelanea
|
||||
* $ONELINER$
|
||||
* Obtiene el tipo de una expresi¢n
|
||||
* $SYNTAX$
|
||||
* TYPE( <cExp> ) --> <cRetType>
|
||||
* $ARGUMENTS$
|
||||
* <cExp> debe ser una expresi¢n de caracteres
|
||||
* $RETURNS$
|
||||
* Una cadena <cRetType> indicando el tipo de la expresi¢n pasada.
|
||||
*
|
||||
* <table>
|
||||
* cRetType Significado
|
||||
*
|
||||
* "A" Array
|
||||
* "B" Block
|
||||
* "C" Cadena de Caracteres
|
||||
* "D" Fecha (Date)
|
||||
* "L" L¢gico
|
||||
* "M" Memo
|
||||
* "N" Numerico
|
||||
* "O" Objeto
|
||||
* "U" Variable NIL, local, static, ¢ no enlazada en la funci¢n
|
||||
* "UE" Error sintaxis en expression ¢ argumentos invalidos
|
||||
* "UI" Funcion con nombre no-reservado fue solicitada
|
||||
* </table>
|
||||
*
|
||||
* $DESCRIPTION$
|
||||
* Esta funci¢n devuelve una cadena que representa el tipo de datos del
|
||||
* argumento. Esta puede ser cualquier expresi¢n v lida de Harbour.
|
||||
*
|
||||
* Si hay un <b>error de sintaxis</b> en la expresi¢n pasada entonces
|
||||
* "UE" es devuelto.
|
||||
*
|
||||
* Si hay una llamada a alguna funci¢n de Harbour no-reservada entonces
|
||||
* "UI" es devuelto (en otras palabras, no hay llamada a la funci¢n UDF
|
||||
* durante la determinaci¢n de tipo - este es un comportamiento
|
||||
* compatible con Clipper). Adicionalmente si la funci¢n de usuario
|
||||
* solicitada no es enlazada dentro del ejecutable final, entonces "U"
|
||||
* es devuelto.
|
||||
*
|
||||
* El tipo de dato de esta expresi¢n es chequeado al invocar al
|
||||
* compilador de macros y por la evaluaci¢n del c¢digo generado (si es
|
||||
* que no hay errores de sintaxis).
|
||||
* Esto causa que TYPE() no pueda determinar un tipo de variable LOCAL
|
||||
* ¢ STATIC, solamente s¡mbolos visibles en tiempo de ejecuci¢n pueden
|
||||
* ser chequeados.
|
||||
*
|
||||
* N¢tese la sutil diferencia entre las funciones TYPE y VALTYPE.
|
||||
* La funci¢n VALTYPE() no llama al compilador de macros, esta
|
||||
* simplemente chequea el tipo del argumento pasado, que puede ser de
|
||||
* cualquier tipo.
|
||||
* La funci¢n TYPE() requiere un argumento de cadena de caracteres con
|
||||
* una expresi¢n v lida de Harbour. El tipo de dato de esta expresi¢n
|
||||
* es retornado.
|
||||
* $EXAMPLES$
|
||||
* ? TYPE( "{ 1, 2 }" ) // prints "A"
|
||||
* ? TYPE( "IIF(.T., SUBSTR('TYPE',2,1), .F.)" ) // prints "C"
|
||||
* ? TYPE( "AT( 'OK', MyUDF())>0" ) // prints "UI"
|
||||
* ? TYPE( "{ 1, 2 }[ 5 ]" ) // prints "UE"
|
||||
*
|
||||
* //--------------------------------------------------------
|
||||
*
|
||||
* LOCAL c
|
||||
* PRIVATE a:="A", b:="B"
|
||||
* ? TYPE( "a + b + c" ) //prints: "U" (variable 'C' es local)
|
||||
*
|
||||
* //--------------------------------------------------------
|
||||
*
|
||||
* LOCAL cFilter := SPACE( 60 )
|
||||
* ACCEPT "Ingrese la expresi¢n de filtro:" TO cFilter
|
||||
*
|
||||
* IF( TYPE( cFilter ) $ "CDLMN" ) )
|
||||
* // Esta es una expresi¢n v lida
|
||||
* SET FILTER TO &cFilter
|
||||
* ENDIF
|
||||
* </fixed>
|
||||
* $STATUS$
|
||||
* R
|
||||
* $COMPLIANCE$
|
||||
*
|
||||
* - Incompatibilidad con Clipper:
|
||||
* En el c¢digo siguiente:
|
||||
*
|
||||
* PRIVATE lCond := 0
|
||||
* ? TYPE( "IIF( lCond, 'true', MyUDF() )" )
|
||||
*
|
||||
* Clipper imprimir "UE" - en Harbour la salida ser "UI"
|
||||
*
|
||||
* - Si "UI" es retornada entonces la sintaxis de la expresi¢n es
|
||||
* correcta. Sin embargo argumentos inv lidos pueden ser pasados
|
||||
* a una function/procedure que cause errores de ejecuci¢n durante
|
||||
* la evaluaci¢n de la expresi¢n.
|
||||
* $FILES$
|
||||
* La Librer¡a es rtl
|
||||
* $SEEALSO$
|
||||
* VALTYPE()
|
||||
* $END$
|
||||
*/
|
||||
|
||||
/* $DOC$
|
||||
* $FUNCNAME$
|
||||
* VALTYPE()
|
||||
* $CATEGORY$
|
||||
* Miscelanea
|
||||
* $ONELINER$
|
||||
* Obtiene el tipo de dato de una expresi¢n
|
||||
* $SYNTAX$
|
||||
* VALTYPE( <xExp> ) --> <cReturnType>
|
||||
* $ARGUMENTS$
|
||||
* <xExp> es cualquier expresi¢n v lida
|
||||
* $RETURNS$
|
||||
* <cReturnType> una caracter indicando el tipo de la expresi¢n pasada
|
||||
* $DESCRIPTION$
|
||||
* Esta funci¢n devuelve un s¢lo car cter el cual representa el tipo de
|
||||
* dato del argumento recibido.
|
||||
* $EXAMPLES$
|
||||
* Ver Test
|
||||
* </fixed>
|
||||
* $TESTS$
|
||||
* FUNCTION Test()
|
||||
* ? ValType( Array( 1 ) ) --> "A"
|
||||
* ? ValType( {|| 1 + 1 } ) --> "B"
|
||||
* ? ValType( "HARBOUR" ) --> "C"
|
||||
* ? ValType( Date() ) --> "D"
|
||||
* ? ValType( .T. ) --> "L"
|
||||
* ? ValType( 1 ) --> "N"
|
||||
* ? ValType( TBrowse() ) --> "O"
|
||||
* ? ValType( NIL ) --> "U"
|
||||
* RETURN NIL
|
||||
* </fixed>
|
||||
* $STATUS$
|
||||
* R
|
||||
* $COMPLIANCE$
|
||||
* VALTYPE() es totalmente compatible con CA-Clipper.
|
||||
* $FILES$
|
||||
* La Librer¡a es rtl
|
||||
* $SEEALSO$
|
||||
* TYPE()
|
||||
* $END$
|
||||
*/
|
||||
|
||||
/* $DOC$
|
||||
* $FUNCNAME$
|
||||
* HB_ISBYREF()
|
||||
* $CATEGORY$
|
||||
* Miscelanea
|
||||
* $ONELINER$
|
||||
* Informa si la variable es pasada por referencia.
|
||||
* $SYNTAX$
|
||||
* HB_ISBYREF( @<Var> ) --> <lVarIsByRef>
|
||||
* $ARGUMENTS$
|
||||
* @<Var> es la variable a testear pasada por referencia.
|
||||
* $RETURNS$
|
||||
* Un valor l¢gico <lVarIsByRef> indicando si la variable es pasada por
|
||||
* referencia a la funci¢n ¢ procedimiento actual.
|
||||
* $DESCRIPTION$
|
||||
* Esta funci¢n devuelve un valor l¢gico indicando si la variable es
|
||||
* pasada por referencia a la funci¢n ¢ procedimiento actual.
|
||||
*
|
||||
* ATENCION:
|
||||
* La variable a testear debe ser pasada por referencia. Si no lo es
|
||||
* la funci¢n retorna NIL.
|
||||
* Esta funci¢n esta basada en la forma que Harbour maneja las variables
|
||||
* por referencia. Cuando una variable es pasada de este modo, la
|
||||
* funci¢n ¢ procedimiento que la recibe, recibe un puntero a la
|
||||
* variable previa, sea esta la variable contenedora de los datos, ¢ un
|
||||
* puntero a otra variable. La funci¢n observa si la variable pasada
|
||||
* apunta a una variable com£n ¢ a la variable pasada por referencia.
|
||||
* $EXAMPLES$
|
||||
* Ver Test
|
||||
* $TESTS$
|
||||
* FUNCTION Main()
|
||||
* local cVar := "Test local"
|
||||
* private nVar := 0
|
||||
*
|
||||
* Test( @cVar, @nVar, cVar, nVar )
|
||||
* RETURN NIL
|
||||
*
|
||||
* PROCEDURE Test( Arg1, Arg2, Arg3, Arg4 )
|
||||
* ? hb_isbyref( @Arg1 ) // .T.
|
||||
* ? hb_isbyref( @Arg2 ) // .T.
|
||||
* ? hb_isbyref( @Arg3 ) // .F.
|
||||
* ? hb_isbyref( @Arg4 ) // .F.
|
||||
* RETURN
|
||||
* </fixed>
|
||||
* $STATUS$
|
||||
* S
|
||||
* $COMPLIANCE$
|
||||
* Esta funci¢n es una extensi¢n de Harbour.
|
||||
* $FILES$
|
||||
* La Librer¡a es rtl
|
||||
* $SEEALSO$
|
||||
* VALTYPE()
|
||||
* $END$
|
||||
*/
|
||||
|
||||
|
||||
Reference in New Issue
Block a user