/*
 * $Id: var.txt 9312 2008-09-05 00:08:34Z vszakats $
 */

/*
 * Las siguientes partes son derechos adquiridos de sus autores individuales.
 * www - http://www.harbour-project.org
 *
 * Copyright 2003 Alejandro de Grate <alex_degarate@hotmail.com>
 * Documentacin en Espaol 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>
 * Documentacin en Ingls de:
 *   __MVPUBLIC(), __MVPRIVATE(), __MVXRELEASE(),
 *  __MVRELEASE(), __MVSCOPE(), __MVCLEAR(),
 *  __MVDBGINFO(), __MVGET(), __MVPUT(), MEMVARBLOCK(),
 *  TYPE()
 *
 * Copyright 1999 Chen Kedem <niki@actcom.co.il>
 * Documentacin en Ingls de: FIELDBLOCK(), FIELDWBLOCK()
 *
 * Copyright 2001 Chen Kedem <niki@actcom.co.il>
 * Documentacin en Ingls de: __MVEXIST()
 *
 * Copyright 2002 Walter Negro <anegro@overnet.com.ar>
 * Documentacin en Ingls de: HB_ISBYREF()
 *
 * Vea doc/license.txt por los trminos de la licencia.
 *
 */

/*  $DOC$
 *  $FUNCNAME$
 *      __MVPUBLIC()
 *  $CATEGORY$
 *      Variable Management
 *  $ONELINER$
 *      Esta funcin 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 funcin 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 funcin es una extensin de Harbour.
 *  $FILES$
 *      La librera asociada es vm
 *  $SEEALSO$
 *      __MVPRIVATE(),__MVXRELEASE()
 *  $END$
 */

/*  $DOC$
 *  $FUNCNAME$
 *      __MVPRIVATE()
 *  $CATEGORY$
 *      Variable Management
 *  $ONELINER$
 *      Esta funcin 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 funcin 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 funcin es una extensin de Harbour.
 *  $FILES$
 *      La librera 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 funcin 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 despus
 *      de salir del procedimiento donde la variable liberada fu creada.
 *      Si Ud. accede la variable liberada en el mismo procedimiento/funcin
 *      donde esta fu creada el valor NIL es devuelto. Ud. puede sin embargo
 *      asignar un nuevo valor a la variable liberada sin ningn efecto
 *      colateral.
 *
 *      Esto libera la variable, an 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 funcin es una extensin de Harbour.
 *  $FILES$
 *      La librera asociada es vm
 *  $SEEALSO$
 *      __MVPRIVATE(),__MVPUBLIC()
 *  $END$
 */

/*  $DOC$
 *  $FUNCNAME$
 *      __MVRELEASE()
 *  $CATEGORY$
 *      Variable Management
 *  $ONELINER$
 *      Esta funcin libera variables PRIVATE
 *  $SYNTAX$
 *      __MVRELEASE( <cMascara>, <lIncludeExclude_flag> )
 *  $ARGUMENTS$
 *      <cMascara>  Cadena que contiene la mscara comodn para los nombres
 *                  de variables que sern liberadas. Los comodines
 *                  soportados son: '*' y '?'
 *
 *      <lIncludeExclude_flag> Valor lgico que esecifica si las variables
 *                  que coinciden con la mscara debieran ser borradas (.T.)
 *                   excluidas del borrado si es .F.
 *  $RETURNS$
 *      Nada
 *  $DESCRIPTION$
 *      Esta funcin 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 despus
 *      de salir del procedimiento donde la variable liberada fu creada.
 *      Si Ud. accede la variable liberada en el mismo procedimiento/funcin
 *      donde esta fu creada el valor NIL es devuelto. Ud. puede sin embargo
 *      asignar un nuevo valor a la variable liberada sin ningn efecto
 *      colateral.
 *      Variables PUBLIC no son cambiadas por esta funcin.
 *  $EXAMPLES$
 *      Ninguno
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      Esta funcin es una extensin de Harbour.
 *  $FILES$
 *      La librera 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 simblicos 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 smbolos)
 *      HB_MV_UNKNOWN        Si la variable No existe (pero fu encontrada
 *                           en la tabla de smbolos)
 *      HB_MV_ERROR          Si la informacin No puede ser obtenida (error
 *                           de memoria  error de argumento).
 *      HB_MV_PUBLIC         para variables pblicas
 *      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 an"
 *        ENDIF
 *
 *      RETURN
 *      </fixed>
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      Esta funcin es una extensin de Harbour.
 *  $FILES$
 *      El archivo de cabecera es ../include/hbmemvar.ch
 *      La librera 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 funcin 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 ejecucin.
 *      Ud tiene que reusar la sentencia PRIVATE  PUBLIC para crear de nuevo
 *      la variable que fue borrada por esta funcin.
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      Esta funcin es una extensin de Harbour.
 *  $FILES$
 *      La librera asociada es vm
 *  $SEEALSO$
 *      __MVPRIVATE(),__MVPUBLIC()
 *  $END$
 */

/*  $DOC$
 *  $FUNCNAME$
 *      __MVDBGINFO()
 *  $CATEGORY$
 *      Variable Management
 *  $ONELINER$
 *      Retorna informacin sobre las variables para el debugger
 *  $SYNTAX$
 *      __MVDBGINFO( <nAlcance> [, <nPosicion> [, @<cNombreVar>] ] )
 *  $ARGUMENTS$
 *      <nAlcance> El alcance de las variables sobre las que la informacin
 *                 es solicitada.
 *                 Valores Soportados (definidos en hbmemvar.ch):
 *                  HB_MV_PUBLIC
 *                  HB_MV_PRIVATE (or any other value)
 *
 *      <nPosicion>  La posicin de la variable solicitada en la lista de
 *                   variables con el alcance especificado. Esta deberia
 *                   comenzar desde la posicin 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 nmero de parmetros pasados
 *  $DESCRIPTION$
 *      Esta funcin obtiene informacin acerca de las variables memvar.
 *      Esta devuelve  bien el nmerode variables con un alcance dado
 *      (Cuando el primer argumento es pasado solamente)  un valor de
 *      variable identificada por su posicin en la la lista de variables
 *      (Cuando el segundo argumento es pasado).
 *      Esta tambin devuelve el nombre de la variable si el tercer argumento
 *      opcional es pasado por referencia.
 *
 *      Si la variable solicitada no existe (la posicin solicitada es mayor
 *      que el nmero de variables definidas), entonces el valor NIL es
 *      devuelto y el nombre de la variable es puesto a  "?"
 *
 *      Como la tabla dinmica de smbolos es usada para encontrar una
 *      variable PUBLIC, las variables PUBLICas son siempre ordenadas
 *      alfabticamente. Las variables PRIVATE son ordenadas en el orden
 *      de su creacin.
 *
 *      Nota:
 *      Debido a la naturaleza dinmica de las variables memvar no hay
 *      garanta 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 funcin debera ser llamada solamente desde el depurador.
 *  $FILES$
 *      La librera 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 funcin 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 funcin es una extensin de Harbour.
 *  $FILES$
 *      La librera asociada es vm
 *  $SEEALSO$
 *      MEMVAR, PRIVATE, PUBLIC
 *  $END$
 */

/*  $DOC$
 *  $FUNCNAME$
 *      __MVGET()
 *  $CATEGORY$
 *      Variable Management
 *  $ONELINER$
 *      Esta funcin 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 funcin devuelve el valor de una variable de memoria PRIVATE 
 *      PUBLIC si la variable existe, de otro modo genera un error en tiempo
 *      de ejecucin.
 *      La variable es especificada por su nombre pasado como parmetro a la
 *      funcin.
 *  $EXAMPLES$
 *      FUNCTION MEMVARBLOCK( cMemvar )
 *      RETURN {|x| IIF( PCOUNT()==0, __MVGET( cMemvar ),;
 *                                    __MVPUT( cMemvar, x ) ) }
 *      </fixed>
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      Esta funcin es una extensin de Harbour.
 *  $FILES$
 *      La librera asociada es vm
 *  $SEEALSO$
 *      __MVPUT()
 *  $END$
 */

/*  $DOC$
 *  $FUNCNAME$
 *      __MVPUT()
 *  $CATEGORY$
 *      Variable Management
 *  $ONELINER$
 *      Esta funcin 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 funcin establece el valor de una variable de memoria PRIVATE 
 *      PUBLIC si la variable existe, de otro modo genera un error en tiempo
 *      de ejecucin.
 *      La variable es especificada por su nombre pasado como parmetro a la
 *      funcin.
 *      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 funcin es una extensin de Harbour.
 *  $FILES$
 *      La librera 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 funcin devuelve un codeblock que establece/obtiene el valor de
 *      una variable PRIVATE  PUBLIC.  Cuando este codeblock es evaluado
 *      sin ningn parmetro pasado, entonces este devuelve el valor actual
 *      de la variable dada.
 *      Si el segundo parmetro es pasado para la evaluacin del codeblock
 *      entonces este valor es usado para establecer el nuevo valor de la
 *      variable dada, el valor pasado es tambin retornado como un valor
 *      la evaluacin 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 funcin es compatible con CA-Cl*pper
 *  $FILES$
 *      La Librera 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 ningn parmetro pasado entonces
 *      este devuelve el valor actual del campo dado.
 *      Si el codeblock es evaluado con un parmetro, entonces su valor es
 *      usado para establecer un nuevo valor para el campo, este valor es
 *      tambin retornado por el bloque.
 *      Si el bloque es evaluado y no hay ningn 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 ningn campo con el nombre
 *      <cFieldName> en el rea actual de trabajo, el codeblock devuelve NIL.
 *
 *      CA-Cl*pper produce un error BASE/1003 si el campo no existe.
 *  $FILES$
 *      La Librera 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>  Nmero 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 ningn parmetro pasado entonces
 *      este devuelve el valor actual del campo dado.
 *      Si el codeblock es evaluado con un parmetro, entonces su valor es
 *      usado para establecer un nuevo valor para el campo, este valor es
 *      tambin retornado por el bloque.
 *      Si el bloque es evaluado y no hay ningn 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 ningn campo con el nombre
 *      <cFieldName> en el rea de trabajo dada, el codeblock devuelve NIL.
 *
 *      CA-Cl*pper produce un error BASE/1003 si el campo no existe.
 *  $FILES$
 *      La Librera es rtl
 *  $SEEALSO$
 *      EVAL(),FIELDBLOCK(),MEMVARBLOCK()
 *  $END$
 */

/*  $DOC$
 *  $FUNCNAME$
 *      TYPE()
 *  $CATEGORY$
 *      Miscelanea
 *  $ONELINER$
 *      Obtiene el tipo de una expresin
 *  $SYNTAX$
 *      TYPE( <cExp> ) --> <cRetType>
 *  $ARGUMENTS$
 *      <cExp>  debe ser una expresin de caracteres
 *  $RETURNS$
 *      Una cadena <cRetType> indicando el tipo de la expresin pasada.
 *
 *      <table>
 *      cRetType   Significado
 *
 *         "A"      Array
 *         "B"      Block
 *         "C"      Cadena de Caracteres
 *         "D"      Fecha (Date)
 *         "L"      Lgico
 *         "M"      Memo
 *         "N"      Numerico
 *         "O"      Objeto
 *         "U"      Variable NIL, local, static,  no enlazada en la funcin
 *         "UE"     Error sintaxis en expression  argumentos invalidos
 *         "UI"     Funcion con nombre no-reservado fue solicitada
 *      </table>
 *
 *  $DESCRIPTION$
 *      Esta funcin devuelve una cadena que representa el tipo de datos del
 *      argumento.  Esta puede ser cualquier expresin vlida de Harbour.
 *
 *      Si hay un <b>error de sintaxis</b> en la expresin pasada entonces
 *      "UE" es devuelto.
 *
 *      Si hay una llamada a alguna funcin de Harbour no-reservada entonces
 *      "UI" es devuelto (en otras palabras, no hay llamada a la funcin UDF
 *      durante la determinacin de tipo  - este es un comportamiento
 *      compatible con Clipper). Adicionalmente si la funcin de usuario
 *      solicitada no es enlazada dentro del ejecutable final, entonces "U"
 *      es devuelto.
 *
 *      El tipo de dato de esta expresin es chequeado al invocar al
 *      compilador de macros y por la evaluacin del cdigo generado (si es
 *      que no hay errores de sintaxis).
 *      Esto causa que TYPE() no pueda determinar un tipo de variable LOCAL
 *       STATIC, solamente smbolos visibles en tiempo de ejecucin pueden
 *      ser chequeados.
 *
 *      Ntese la sutil diferencia entre las funciones TYPE y VALTYPE.
 *      La funcin VALTYPE() no llama al compilador de macros, esta
 *      simplemente chequea el tipo del argumento pasado, que puede ser de
 *      cualquier tipo.
 *      La funcin TYPE() requiere un argumento de cadena de caracteres con
 *      una expresin vlida de Harbour.  El tipo de dato de esta expresin
 *      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 expresin de filtro:" TO cFilter
 *
 *       IF( TYPE( cFilter ) $ "CDLMN" ) )
 *          // Esta es una expresin vlida
 *          SET FILTER TO &cFilter
 *       ENDIF
 *      </fixed>
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *
 *      - Incompatibilidad con Clipper:
 *          En el cdigo 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 expresin es
 *          correcta. Sin embargo argumentos invlidos pueden ser pasados
 *          a una function/procedure que cause errores de ejecucin durante
 *          la evaluacin de la expresin.
 *  $FILES$
 *      La Librera es rtl
 *  $SEEALSO$
 *      VALTYPE()
 *  $END$
 */

/*  $DOC$
 *  $FUNCNAME$
 *      VALTYPE()
 *  $CATEGORY$
 *      Miscelanea
 *  $ONELINER$
 *      Obtiene el tipo de dato de una expresin
 *  $SYNTAX$
 *      VALTYPE( <xExp> ) --> <cReturnType>
 *  $ARGUMENTS$
 *      <xExp>  es cualquier expresin vlida
 *  $RETURNS$
 *      <cReturnType> una caracter indicando el tipo de la expresin pasada
 *  $DESCRIPTION$
 *      Esta funcin devuelve un slo carcter 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-Cl*pper.
 *  $FILES$
 *      La Librera 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 lgico <lVarIsByRef> indicando si la variable es pasada por
 *      referencia a la funcin  procedimiento actual.
 *  $DESCRIPTION$
 *      Esta funcin devuelve un valor lgico indicando si la variable es
 *      pasada por referencia a la funcin  procedimiento actual.
 *
 *      ATENCION:
 *      La variable a testear debe ser pasada por referencia. Si no lo es
 *      la funcin retorna NIL.
 *      Esta funcin esta basada en la forma que Harbour maneja las variables
 *      por referencia.  Cuando una variable es pasada de este modo, la
 *      funcin  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 funcin observa si la variable pasada
 *      apunta a una variable comn  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 funcin es una extensin de Harbour.
 *  $FILES$
 *      La Librera es rtl
 *  $SEEALSO$
 *      VALTYPE()
 *  $END$
 */


