/*
 * Header file for Class commands
 *
 * Copyright 1999 Antonio Linares <alinares@fivetechsoft.com>
 * Copyright 2000-07 JF. Lefebvre <jfl@mafact.com> & RA. Cuylen <rac@mafact.com> (Class(y), TopClass and Visual Object compatibility, multiple inheritance)
 * Copyright 2000-08-2001 JF. Lefebvre <jfl@mafact.com> (Scoping, Delegating, DATA Shared, Support of 10 Chars limits)
 * Copyright 2006 Przemyslaw Czerpak <druzus / at / priv.onet.pl>
 *    most of rules rewritten
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2, or (at your option)
 * any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; see the file LICENSE.txt.  If not, write to
 * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
 * Boston, MA 02110-1301 USA (or visit https://www.gnu.org/licenses/).
 *
 * As a special exception, the Harbour Project gives permission for
 * additional uses of the text contained in its release of Harbour.
 *
 * The exception is that, if you link the Harbour libraries with other
 * files to produce an executable, this does not by itself cause the
 * resulting executable to be covered by the GNU General Public License.
 * Your use of that executable is in no way restricted on account of
 * linking the Harbour library code into it.
 *
 * This exception does not however invalidate any other reasons why
 * the executable file might be covered by the GNU General Public License.
 *
 * This exception applies only to the code released by the Harbour
 * Project under the name Harbour.  If you copy code from other
 * Harbour Project or Free Software Foundation releases into a copy of
 * Harbour, as the General Public License permits, the exception does
 * not apply to the code that you add in this way.  To avoid misleading
 * anyone as to the status of such modified files, you must delete
 * this exception notice from them.
 *
 * If you write modifications of your own for Harbour, it is your choice
 * whether to permit this exception to apply to your modifications.
 * If you do not wish that, delete this exception notice.
 *
 */

#ifndef HB_CLASS_CH_
#define HB_CLASS_CH_

#include "hboo.ch"

/* You can actually define one or all the syntax, they do not collide each other */
/* There is some difference with their original form and I hope I will have enough */
/* time to document it <g> */
/* This is work in progress ... */
/* FWOBJECT AND CLASSY compatibility are the base of this work */
/* VO is just here as I like it's way of */
/* instantiating object but there is only a very few VO keywords here :-( */
/* TOPCLASS is better implemented because I like the way some Classy command */
/* are simplified */
/* There is also a big common block extending in fact each of the four base syntax */
/* it seem actually impossible to completely separate it without creating */
/* four different include files (what I would not see in fact ) */

/* There is also two compatibility define you can use */
/* HB_CLS_NOTOBJECT which IF DEFINED, disable the auto inherit of HBObject */
/* (which in fact also disable the classy compatibility :new(...) => :Init(...) */
/* HB_CLS_NOAUTOINIT which disable the (VO like) AutoInit for Logical, Numeric, */
/* Date and Timestamp when not specifically initiated */
/* These two are disabled by default */
/* So Each class _inherit_ of HBObject by default and */
/*    Each logical, numeric, date and timestamp typed variable is initiated to */
/*    .F., 0, CToD( "" ) and t"00:00" by default */

/* #define HB_CLS_NOTOBJECT       */ /* Should be included in some compatibility include files as needed */
/* #define HB_CLS_NOAUTOINIT      */ /* Idem */
/* #define HB_CLS_NO_DECORATION   */ /* disable adding <class>_ prefix to method function names */
/* #define HB_CLS_NO_PARAMS_ERR   */ /* disable parameters validation in method declaration and implementation */
/* #define HB_CLS_NO_OO_ERR       */ /* disable all code validation */
/* #define HB_CLS_NO_DECLARATIONS */ /* disable value type declarations */

#ifndef HB_CLS_FWO
#ifndef HB_CLS_CSY
#ifndef HB_CLS_VO
#ifndef HB_CLS_TOP

/* IF NOTHING DECIDED BY THE PROGRAMMER USE ALL */
#define HB_CLS_FWO
#define HB_CLS_CSY
#define HB_CLS_VO
#define HB_CLS_TOP
#define HB_CLS_XPP

#endif
#endif
#endif
#endif


/* Disable method decoration when Harbour compiled strict compatibility mode.
   In strict mode, PP doesn't support identifier concatenation, which
   would be needed for method decoration. */
#ifdef HB_CLP_STRICT
   #ifndef HB_CLS_NO_DECORATION
      #define HB_CLS_NO_DECORATION
   #endif
   #ifndef HB_CLS_PARAM_LIST
      #define HB_CLS_PARAM_LIST
   #endif
#endif

/* disable strict parameters validation in method declaration and
   implementation when warning level (-w?) is not 3 or higher */
#if __pragma( WARNINGLEVEL ) < 3
   #ifndef HB_CLS_NO_PARAMS_ERR
      #define HB_CLS_NO_PARAMS_ERR
   #endif
#endif

/* should we use <ClassName>_ prefix for real method names? */
#ifdef HB_CLS_NO_DECORATION
   #xtranslate __HB_CLS_MTHNAME <!ClassName!> <MethodName> => <MethodName>
#else
   #xtranslate __HB_CLS_MTHNAME <!ClassName!> <MethodName> => <ClassName>_<MethodName>
#endif

/* parameters list passed throw - it's Harbour extension */
#ifndef HB_CLS_PARAM_LIST
   #define HB_CLS_PARAM_LIST ...
#endif

/* should we use _HB_CLASS/_HB_MEMBER declarations? */
#ifdef HB_CLS_NO_DECLARATIONS
   #xcommand _HB_CLASS  <name>        =>
   #xcommand _HB_CLASS  <name> <name> =>
   #xcommand _HB_MEMBER <name>        =>
   #xcommand DECLARE    <*decl*>      =>
   #xtranslate AS <type>              =>
   #xtranslate AS CLASS <name>        =>
#endif

/* should we inherit from HBObject class by default ? */
#ifdef HB_CLS_NOTOBJECT
   #xtranslate __HB_CLS_PAR([<cls,...>])  => { <cls> }
#else
   #xtranslate __HB_CLS_PAR([<cls,...>])  => iif( <.cls.>, { <cls> }, { @HBObject() } )
#endif

/* Should we initialize typed instance variables? */
#ifdef HB_CLS_NOAUTOINIT
   #define __HB_CLS_NOINI .T.
#else
   #define __HB_CLS_NOINI .F.
#endif

/* Should we generate compile error when method declaration has different parameters? */
#ifdef HB_CLS_NO_PARAMS_ERR
   #xtranslate __HB_CLS_PARAMS(<Method>)     => __HB_CLS_ASID(<Method>)
#else
   #xtranslate __HB_CLS_PARAMS(<Method>)     => <Method>
#endif

/* Should we disable compile errors for undeclared methods? */
#ifdef HB_CLS_NO_OO_ERR
   #xtranslate __HB_CLS_ERR([<msg,...>]) =>
   #xtranslate __HB_CLS_WARN([<msg,...>]) =>
#else
   #xtranslate __HB_CLS_ERR([<msg,...>]) => ;#error [ <msg>] ; #line
   #xtranslate __HB_CLS_WARN([<msg,...>]) => ;#warning [ <msg>] ; #line
#endif

/* disabled by default to not generate ignored by compiler noise in .ppo files */
#if 0
DECLARE HBClass ;
        New( cName AS String, OPTIONAL SuperParams ) AS CLASS HBClass ;
        Create() AS Object ;
        Instance() AS Object ;
        AddClsMethod( cName AS String, @MethodName(), nScope AS Numeric, n2 AS Numeric, n3 AS Numeric ) ;
        AddMultiClsData( cType AS String, uVal, nScope AS Numeric, aDatas AS Array OF String ) ;
        AddMultiData( cType AS String, uVal, nScope AS Numeric, aDatas AS Array OF String, x AS LOGICAL, lPer AS LOGICAL ) ;
        AddMethod( cName AS String, @MethodName(), nScope AS Numeric ) ;
        AddInLine( cName AS String, bBlock AS CodeBlock, nScope AS Numeric ) ;
        AddVirtual( cName AS String )
#endif

/*
 * Class(y) like non virtual send operator but instead of using early
 * bindings it casts object to class in which current method were defined.
 */
#translate @:<!MessageName!>([<MsgParams,...>]) => ;
                                ::realclass:<MessageName>([ <MsgParams>])

/* Indirect super casting translation */
#xtranslate :Super( <!SuperClass!> ): => :<SuperClass>:


#xtranslate __HB_CLS_OPT(<a>,<b>) =>  <a>
#xtranslate __HB_CLS_OPT(<a>)     =>  <a>

#xtranslate __HB_CLS_ASSTRING( <FuncName> )                 => <(FuncName)>
#xtranslate __HB_CLS_ASSTRING( <FuncName>([<params,...>]) ) => <(FuncName)>
#xtranslate __HB_CLS_ASFUNC( <FuncName> )                   => <FuncName>()
#xtranslate __HB_CLS_ASFUNC( <FuncName>([<params,...>]) )   => <FuncName>([ <params>])
#xtranslate __HB_CLS_ASID( <FuncName> )                     => <FuncName>
#xtranslate __HB_CLS_ASID( <FuncName>([<params,...>]) )     => <FuncName>
#xtranslate __HB_CLS_ASARGS( <FuncName> )                   =>
#xtranslate __HB_CLS_ASARGS( <FuncName>([<Args,...>]) )     => [ <Args>]
#xtranslate __HB_CLS_ASARGSOPT( <FuncName> )                =>
#xtranslate __HB_CLS_ASARGSOPT( <FuncName>([<Args,...>]) )  => [, <Args>]

/*
#xtranslate __HB_CLS_VARERR(<var>)                    => __HB_CLS_ERR( Invalid instance variable name \<<var>> )
#xtranslate __HB_CLS_ISVAR( <var> )                   => __HB_CLS_VARERR(<var>)
#xtranslate __HB_CLS_ISVAR( <!var!> )                 =>
#xcommand __HB_CLS_CHECKVAR( <param1> [,<paramN>] )   => __HB_CLS_ISVAR( <param1> ) [;__HB_CLS_ISVAR( <paramN> )]
*/

/* #xtranslate __HB_CLS_SCOPE( <export>, <protect>, <hidde> ) => ;
      iif( <export>, HB_OO_CLSTP_EXPORTED , ;
      iif( <protect>, HB_OO_CLSTP_PROTECTED, ;
      iif( <hidde>, HB_OO_CLSTP_HIDDEN, nScope ) ) ) */
#xtranslate __HB_CLS_SCOPE( <x,...> )        => ) __HB_CLS_ERR( Can not use multiple scope qualifiers! )
#xtranslate __HB_CLS_SCOPE( .T., .F., .F. )  => HB_OO_CLSTP_EXPORTED
#xtranslate __HB_CLS_SCOPE( .F., .T., .F. )  => HB_OO_CLSTP_PROTECTED
#xtranslate __HB_CLS_SCOPE( .F., .F., .T. )  => HB_OO_CLSTP_HIDDEN
#xtranslate __HB_CLS_SCOPE( .F., .F., .F. )  => nScope /* Default */


#xcommand CLASS <!ClassName!> [METACLASS <!metaClass!>] ;
             [ <frm: FROM, INHERIT> <!SuperClass1!> [,<!SuperClassN!>] ] ;
             [ <modulfriend: MODULE FRIENDLY> ] ;
             [ <static: STATIC> ] [ FUNCTION <FuncName> ] => ;
   _HB_CLASS <ClassName> <FuncName> ;;
   <static> function __HB_CLS_OPT( [<FuncName>,] <ClassName> ) ( HB_CLS_PARAM_LIST ) ;;
      STATIC s_oClass ;;
      LOCAL nScope, oClass, oInstance ;;
      IF s_oClass == NIL .AND. __clsLockDef( @s_oClass ) ;;
         BEGIN SEQUENCE ;;
            nScope := HB_OO_CLSTP_EXPORTED ; HB_SYMBOL_UNUSED( nScope ) ;;
            oClass  := iif( <.metaClass.>, <(metaClass)>, HBClass():new( <(ClassName)>, __HB_CLS_PAR( [ @<SuperClass1>() ] [ , @<SuperClassN>() ] ), @__HB_CLS_OPT([__HB_CLS_ASID(<FuncName>),] <ClassName>)() [, <.modulfriend.> ] ) ) ;;
   #undef  _CLASS_NAME_ ; #define _CLASS_NAME_ <ClassName> ;;
   #undef  _CLASS_MODE_ ; #define _CLASS_MODE_ _CLASS_DECLARATION_

#xcommand ENDCLASS [<lck: LOCK, LOCKED>] => ;
            oClass:Create() ; [<-lck-> __clsLock( oClass:hClass ) ] ;;
         ALWAYS ;;
            __clsUnlockDef( @s_oClass, oClass ) ;;
         END SEQUENCE ;;
         oInstance := oClass:Instance() ;;
         IF __objHasMsg( oInstance, "InitClass" ) ;;
            oInstance:InitClass( HB_CLS_PARAM_LIST ) ;;
         END ;;
         RETURN oInstance ;;
      END ;;
      RETURN s_oClass:Instance() AS CLASS _CLASS_NAME_ ;;
   #undef  _CLASS_MODE_ ; #define _CLASS_MODE_ _CLASS_IMPLEMENTATION_


#xcommand DECLARED METHOD <type: FUNCTION, PROCEDURE> <MethodName> CLASS <!ClassName!> => ;
      static <type> __HB_CLS_MTHNAME <ClassName> <MethodName> ;;
      local Self AS CLASS <ClassName> := QSelf() AS CLASS <ClassName>

#xcommand __HB_CLS_DECLARE_METHOD <MethodName> <!ClassName!> => ;
   #xcommand METHOD \<type: FUNCTION, PROCEDURE> <MethodName> CLASS <ClassName> _CLASS_IMPLEMENTATION_ => ;
         DECLARED METHOD \<type> <MethodName> CLASS <ClassName>

#xcommand __HB_CLS_DECLARE_METHOD <!MethodName!> <!ClassName!> => ;
   #xcommand METHOD \<type: FUNCTION, PROCEDURE> <MethodName> CLASS <ClassName> _CLASS_IMPLEMENTATION_ => ;
         DECLARED METHOD \<type> <MethodName> CLASS <ClassName> ;;
   #xcommand METHOD \<type: FUNCTION, PROCEDURE> <MethodName>(\[ \<xparams,...>] ) CLASS <ClassName> _CLASS_IMPLEMENTATION_ => ;
         DECLARED METHOD \<type> <MethodName>(\[ \<xparams>] ) CLASS <ClassName>

#xcommand METHOD <type: FUNCTION, PROCEDURE> <MethodName> CLASS <!ClassName!> _CLASS_IMPLEMENTATION_ => ;
   __HB_CLS_WARN( Method \<<MethodName>> not declared or declaration mismatch in class \<<ClassName>> ) ;;
   DECLARED METHOD <type> <MethodName> CLASS <ClassName>

#xcommand METHOD <MethodName> [ <ctor: CONSTRUCTOR> ] [ AS <type> ] [ <export: EXPORTED, VISIBLE>] [<protect: PROTECTED>] [<hidde: HIDDEN>] [<persistent: PERSISTENT, PROPERTY>] [<sync: SYNC>] [_CLASS_DECLARATION_] => ;
   _HB_MEMBER __HB_CLS_ASFUNC(<MethodName>) [<-ctor-> AS CLASS _CLASS_NAME_] [ AS <type> ];;
   __HB_CLS_DECLARE_METHOD __HB_CLS_PARAMS(<MethodName>) _CLASS_NAME_ ;;
   oClass:AddMethod( __HB_CLS_ASSTRING(<MethodName>), @__HB_CLS_ASID( __HB_CLS_MTHNAME _CLASS_NAME_ <MethodName> )(), __HB_CLS_SCOPE( <.export.>, <.protect.>, <.hidde.> ) + iif( <.ctor.>, HB_OO_CLSTP_CTOR, 0 ) + iif( <.persistent.>, HB_OO_CLSTP_PERSIST, 0 ) + iif( <.sync.>, HB_OO_CLSTP_SYNC, 0 ) )

#xcommand ACCESS <AccessName> [ AS <type> ] [ <export: EXPORTED, VISIBLE>] [<protect: PROTECTED>] [<hidde: HIDDEN>] [<persistent: PERSISTENT, PROPERTY>] [<sync: SYNC>] [_CLASS_DECLARATION_] => ;
   METHOD <AccessName> [ AS <type> ] <export> <protect> <hidde> <persistent> <sync> _CLASS_DECLARATION_

#xcommand ASSIGN <AssignName> [ AS <type> ] [ <export: EXPORTED, VISIBLE>] [<protect: PROTECTED>] [<hidde: HIDDEN>] [<persistent: PERSISTENT, PROPERTY>] [<sync: SYNC>] [_CLASS_DECLARATION_] => ;
   METHOD _<AssignName> [ AS <type> ] <export> <protect> <hidde> <persistent> <sync> _CLASS_DECLARATION_

#xcommand METHOD <type: FUNCTION, PROCEDURE> <MethodName> [CLASS <!ClassName!>] => ;
   METHOD <type> <MethodName> CLASS __HB_CLS_OPT([<ClassName>,] _CLASS_NAME_) _CLASS_MODE_
#xcommand METHOD <MethodName> CLASS <!ClassName!> => METHOD FUNCTION  <MethodName> CLASS <ClassName> _CLASS_MODE_
#xcommand ACCESS <AccessName> CLASS <!ClassName!> => METHOD FUNCTION  <AccessName> CLASS <ClassName> _CLASS_MODE_
#xcommand ASSIGN <AssignName> CLASS <!ClassName!> => METHOD FUNCTION _<AssignName> CLASS <ClassName> _CLASS_MODE_

#xcommand METHOD <MethodName> _CLASS_IMPLEMENTATION_ => ;
   METHOD FUNCTION <MethodName> CLASS _CLASS_NAME_
#xcommand METHOD <MethodName> => METHOD <MethodName> _CLASS_MODE_

/* For backward compatibility */
#xcommand PROCEDURE <MethodName> CLASS <!ClassName!> => METHOD PROCEDURE <MethodName> CLASS <ClassName> _CLASS_MODE_


/* special method(s) */
#xcommand CONSTRUCTOR <Name>        => METHOD <Name> CONSTRUCTOR
#xcommand DESTRUCTOR <!MethodName!>[<par: ()>] [_CLASS_DECLARATION_] => ;
   _HB_MEMBER __HB_CLS_ASFUNC(<MethodName>)<-par->;;
   __HB_CLS_DECLARE_METHOD __HB_CLS_PARAMS(<MethodName>) _CLASS_NAME_ ;;
   oClass:SetDestructor( @__HB_CLS_ASID( __HB_CLS_MTHNAME _CLASS_NAME_ <MethodName> )() )
#xcommand DESTRUCTOR FUNCTION <!FuncName!>[<par: ()>] => ;
   oClass:SetDestructor( @<FuncName>() )<-par->
#xcommand DESTRUCTOR <!MethodName!>[<par: ()>] [CLASS <!ClassName!>] _CLASS_IMPLEMENTATION_ => ;
   METHOD PROCEDURE <MethodName>[<par>] [CLASS <ClassName>] _CLASS_IMPLEMENTATION_
#xcommand DESTRUCTOR <MethodName> [CLASS <!ClassName!>] => ;
   DESTRUCTOR <MethodName> [CLASS <ClassName>] _CLASS_MODE_

#xcommand ON ERROR <MethodName>     => ERROR HANDLER <MethodName>
#xcommand ERROR HANDLER <MethodName> => ;
   _HB_MEMBER __HB_CLS_ASFUNC(<MethodName>);;
   __HB_CLS_DECLARE_METHOD __HB_CLS_PARAMS(<MethodName>) _CLASS_NAME_ ;;
   oClass:SetOnError( @__HB_CLS_ASID( __HB_CLS_MTHNAME _CLASS_NAME_ <MethodName> )() )
#xcommand ON ERROR FUNCTION <FuncName> => ;
   oClass:SetOnError( @__HB_CLS_ASID( <FuncName> )() )

/* Friend function/class definitions */
#xcommand FRIEND CLASS <ClassName1> [, <ClassNameN> ] => ;
   oClass:AddFriendClass( @__HB_CLS_ASID(<ClassName1>)() [, @__HB_CLS_ASID(<ClassNameN>)() ] )

#xcommand FRIEND FUNCTION <FuncName1> [, <FuncNameN> ] => ;
   oClass:AddFriendFunc( @__HB_CLS_ASID(<FuncName1>)() [, @__HB_CLS_ASID(<FuncNameN>)() ] )

/* Operator overloading */
#xcommand OPERATOR <op> [<arg: ARG, ARGS> <Args,...>] [LOCAL <Locals,...>] INLINE <Code,...> [ <export: EXPORTED, VISIBLE>] [<protect: PROTECTED>] [<hidde: HIDDEN>] [<sync: SYNC>] => ;
   oClass:AddInline( <(op)>, {|Self [,<Args>] [,<Locals>]| HB_SYMBOL_UNUSED(Self), <Code>}, __HB_CLS_SCOPE( <.export.>, <.protect.>, <.hidde.> ) + iif( <.sync.>, HB_OO_CLSTP_SYNC, 0 ) )

#xcommand METHOD <MethodName> [ AS <type> ] OPERATOR <op> [ <export: EXPORTED, VISIBLE>] [<protect: PROTECTED>] [<hidde: HIDDEN>] [<sync: SYNC>] => ;
   _HB_MEMBER __HB_CLS_ASFUNC(<MethodName>) [ AS <type> ];;
   __HB_CLS_DECLARE_METHOD __HB_CLS_PARAMS(<MethodName>) _CLASS_NAME_ ;;
   oClass:AddMethod( <(op)>, @__HB_CLS_ASID( __HB_CLS_MTHNAME _CLASS_NAME_ <MethodName> )(), __HB_CLS_SCOPE( <.export.>, <.protect.>, <.hidde.> ) + iif( <.sync.>, HB_OO_CLSTP_SYNC, 0 ) )

#xcommand OPERATOR <op> FUNCTION <FuncName> [ <export: EXPORTED, VISIBLE>] [<protect: PROTECTED>] [<hidde: HIDDEN>] [<sync: SYNC>] => ;
   oClass:AddMethod( <(op)>, @__HB_CLS_ASID( <FuncName> )(), __HB_CLS_SCOPE( <.export.>, <.protect.>, <.hidde.> ) + iif( <.sync.>, HB_OO_CLSTP_SYNC, 0 ) )

/* Set/Get Method */
#xcommand METHOD <MethodName> [ AS <type> ] SETGET [ <export: EXPORTED, VISIBLE>] [<protect: PROTECTED>] [<hidde: HIDDEN>] [<ro: READONLY, RO>] [<persistent: PERSISTENT, PROPERTY>] [<sync: SYNC>] => ;
   _HB_MEMBER __HB_CLS_ASFUNC(<MethodName>) [ AS <type> ];;
   _HB_MEMBER __HB_CLS_ASFUNC(_<MethodName>) [ AS <type> ];;
   __HB_CLS_DECLARE_METHOD __HB_CLS_PARAMS(<MethodName>) _CLASS_NAME_ ;;
   oClass:AddMethod( __HB_CLS_ASSTRING(<MethodName>), @__HB_CLS_ASID( __HB_CLS_MTHNAME _CLASS_NAME_ <MethodName> )(), __HB_CLS_SCOPE( <.export.>, <.protect.>, <.hidde.> ) + iif( <.persistent.>, HB_OO_CLSTP_PERSIST, 0 ) + iif( <.sync.>, HB_OO_CLSTP_SYNC, 0 ) ) ;;
   oClass:AddMethod( __HB_CLS_ASSTRING(_<MethodName>), @__HB_CLS_ASID( __HB_CLS_MTHNAME _CLASS_NAME_ <MethodName> )(), __HB_CLS_SCOPE( <.export.>, <.protect.>, <.hidde.> ) + iif( <.ro.>, HB_OO_CLSTP_READONLY, 0 ) + iif( <.persistent.>, HB_OO_CLSTP_PERSIST, 0 ) + iif( <.sync.>, HB_OO_CLSTP_SYNC, 0 ) )

/* Message definitions */

/* Virtual / Deferred Methods */
#xcommand MESSAGE <MessageName> [ AS <type> ] VIRTUAL => ;
   _HB_MEMBER __HB_CLS_ASFUNC(<MessageName>) ;;
   oClass:AddVirtual( __HB_CLS_ASSTRING(<MessageName>) )

#xcommand MESSAGE <MessageName> [ AS <type> ] DEFERRED => ;
   MESSAGE <MessageName> [ AS <type> ] VIRTUAL

#xcommand MESSAGE <MessageName> [ AS <type> ] IS DEFERRED => ;
   MESSAGE <MessageName> [ AS <type> ] VIRTUAL

#xcommand MESSAGE <MessageName> [ AS <type> ] METHOD <MethodName> [<ctor: CONSTRUCTOR>] [<export: EXPORTED, VISIBLE>] [<protect: PROTECTED>] [<hidde: HIDDEN>] [<persistent: PERSISTENT, PROPERTY>] [<sync: SYNC>] => ;
   _HB_MEMBER __HB_CLS_ASFUNC(<MessageName>) [<-ctor-> AS CLASS _CLASS_NAME_] [ AS <type> ];;
   __HB_CLS_DECLARE_METHOD __HB_CLS_PARAMS(<MethodName>) _CLASS_NAME_ ;;
   oClass:AddMethod( __HB_CLS_ASSTRING(<MessageName>), @__HB_CLS_ASID( __HB_CLS_MTHNAME _CLASS_NAME_ <MethodName> )(), __HB_CLS_SCOPE( <.export.>, <.protect.>, <.hidde.> ) + iif( <.ctor.>, HB_OO_CLSTP_CTOR, 0 ) + iif( <.persistent.>, HB_OO_CLSTP_PERSIST, 0 ) + iif( <.sync.>, HB_OO_CLSTP_SYNC, 0 ) )

#xcommand MESSAGE <MessageName> [ AS <type> ] EXTERN <FuncName> [<ctor: CONSTRUCTOR>] [<export: EXPORTED, VISIBLE>] [<protect: PROTECTED>] [<hidde: HIDDEN>] [<persistent: PERSISTENT, PROPERTY>] [<sync: SYNC>] => ;
   _HB_MEMBER __HB_CLS_ASFUNC(<MessageName>) [<-ctor-> AS CLASS _CLASS_NAME_] [ AS <type> ];;
   oClass:AddMethod( __HB_CLS_ASSTRING(<MessageName>), @__HB_CLS_ASID( <FuncName> )(), __HB_CLS_SCOPE( <.export.>, <.protect.>, <.hidde.> ) + iif( <.ctor.>, HB_OO_CLSTP_CTOR, 0 ) + iif( <.persistent.>, HB_OO_CLSTP_PERSIST, 0 ) + iif( <.sync.>, HB_OO_CLSTP_SYNC, 0 ) )

#xcommand MESSAGE <MessageName> [ AS <type> ] BLOCK <CodeBlock> [<ctor: CONSTRUCTOR>] [<export: EXPORTED, VISIBLE>] [<protect: PROTECTED>] [<hidde: HIDDEN>] [<persistent: PERSISTENT, PROPERTY>] [<sync: SYNC>] => ;
   _HB_MEMBER __HB_CLS_ASFUNC(<MessageName>) [<-ctor-> AS CLASS _CLASS_NAME_] [ AS <type> ];;
   oClass:AddInline( __HB_CLS_ASSTRING(<MessageName>), <CodeBlock>, __HB_CLS_SCOPE( <.export.>, <.protect.>, <.hidde.> ) + iif( <.ctor.>, HB_OO_CLSTP_CTOR, 0 ) + iif( <.persistent.>, HB_OO_CLSTP_PERSIST, 0 ) + iif( <.sync.>, HB_OO_CLSTP_SYNC, 0 ) )

#xcommand MESSAGE <MessageName> [ AS <type> ] [LOCAL <Locals,...>] INLINE <Code,...> [<ctor: CONSTRUCTOR>] [<export: EXPORTED, VISIBLE>] [<protect: PROTECTED>] [<hidde: HIDDEN>] [<persistent: PERSISTENT, PROPERTY>] [<sync: SYNC>] => ;
   MESSAGE <MessageName> [ AS <type> ] BLOCK {|Self __HB_CLS_ASARGSOPT(<MessageName>) [,<Locals>]| HB_SYMBOL_UNUSED(Self), <Code>} <ctor> <export> <protect> <hidde> <persistent> <sync>

#xcommand MESSAGE <MessageName> [ AS <type> ] <arg: ARG, ARGS> <Args,...> [LOCAL <Locals,...>] INLINE <Code,...> [<ctor: CONSTRUCTOR>] [<export: EXPORTED, VISIBLE>] [<protect: PROTECTED>] [<hidde: HIDDEN>] [<persistent: PERSISTENT, PROPERTY>] [<sync: SYNC>] => ;
   MESSAGE __HB_CLS_ASID(<MessageName>)(<Args>) [ AS <type> ] [LOCAL <Locals>] INLINE <Code> <ctor> <export> <protect> <hidde> <persistent> <sync>

#xcommand MESSAGE <MessageName> [ AS <type> ] IS <AltMsgName> [<ctor: CONSTRUCTOR>] [<export: EXPORTED, VISIBLE>] [<protect: PROTECTED>] [<hidde: HIDDEN>] [<persistent: PERSISTENT, PROPERTY>] [<sync: SYNC>] => ;
   MESSAGE <MessageName> [ AS <type> ] INLINE Self:<AltMsgName> <ctor> <export> <protect> <hidde> <persistent> <sync>

#xcommand MESSAGE <MessageName> [ AS <type> ] TO <oObject> [<export: EXPORTED, VISIBLE>] [<protect: PROTECTED>] [<hidde: HIDDEN>] [<persistent: PERSISTENT, PROPERTY>] [<sync: SYNC>] => ;
   MESSAGE <MessageName> [ AS <type> ] INLINE Self:<oObject>:<MessageName> <export> <protect> <hidde> <persistent> <sync>

#xcommand MESSAGE <MessageName> [ AS <type> ] IN <!SuperClass!> [<export: EXPORTED, VISIBLE>] [<protect: PROTECTED>] [<hidde: HIDDEN>] [<persistent: PERSISTENT, PROPERTY>] [<sync: SYNC>] => ;
   MESSAGE <MessageName> [ AS <type> ] INLINE Self:<SuperClass>:<MessageName> <export> <protect> <hidde> <persistent> <sync>

#xcommand MESSAGE <MessageName> [ AS <type> ] IS <AltMsgName> TO <oObject> [<export: EXPORTED, VISIBLE>] [<protect: PROTECTED>] [<hidde: HIDDEN>] [<persistent: PERSISTENT, PROPERTY>] [<sync: SYNC>] => ;
   MESSAGE <MessageName> [ AS <type> ] INLINE Self:<oObject>:__HB_CLS_ASID(<AltMsgName>)(__HB_CLS_ASARGS(<MessageName>)) <export> <protect> <hidde> <persistent> <sync>

#xcommand MESSAGE <MessageName> [ AS <type> ] IS <SprMethodName> IN <!SuperClass!> [<export: EXPORTED, VISIBLE>] [<protect: PROTECTED>] [<hidde: HIDDEN>] [<persistent: PERSISTENT, PROPERTY>] [<sync: SYNC>] => ;
   MESSAGE <MessageName> [ AS <type> ] INLINE Self:<SuperClass>:__HB_CLS_ASID(<SprMethodName>)(__HB_CLS_ASARGS(<MessageName>)) <export> <protect> <hidde> <persistent> <sync>

#xcommand DELEGATE <MessageName> [ AS <type> ] TO <oObject> [<export: EXPORTED, VISIBLE>] [<protect: PROTECTED>] [<hidde: HIDDEN>] [<persistent: PERSISTENT, PROPERTY>] [<sync: SYNC>] =>;
   MESSAGE <MessageName> [ AS <type> ] TO <oObject> <export> <protect> <hidde> <persistent> <sync>

#xcommand ACCESS <MessageName> [ AS <type> ] [LOCAL <Locals,...>] INLINE <Code,...> [<export: EXPORTED, VISIBLE>] [<protect: PROTECTED>] [<hidde: HIDDEN>] [<persistent: PERSISTENT, PROPERTY>] [<sync: SYNC>] => ;
   MESSAGE <MessageName> [ AS <type> ] [LOCAL <Locals>] INLINE <Code> <export> <protect> <hidde> <persistent> <sync>

#xcommand ASSIGN <MessageName> [ AS <type> ] [LOCAL <Locals,...>] INLINE <Code,...> [<export: EXPORTED, VISIBLE>] [<protect: PROTECTED>] [<hidde: HIDDEN>] [<persistent: PERSISTENT, PROPERTY>] [<sync: SYNC>] => ;
   MESSAGE _<MessageName> [ AS <type> ] [LOCAL <Locals>] INLINE <Code> <export> <protect> <hidde> <persistent> <sync>

#xcommand ACCESS <MessageName> [ AS <type> ] <mth: METHOD, IS> <MethodName> [<export: EXPORTED, VISIBLE>] [<protect: PROTECTED>] [<hidde: HIDDEN>] [<persistent: PERSISTENT, PROPERTY>] [<sync: SYNC>] => ;
   MESSAGE <MessageName> [ AS <type> ] <mth> <MethodName> <export> <protect> <hidde> <persistent> <sync>

#xcommand ASSIGN <MessageName> [ AS <type> ] <mth: METHOD, IS> <MethodName> [<export: EXPORTED, VISIBLE>] [<protect: PROTECTED>] [<hidde: HIDDEN>] [<persistent: PERSISTENT, PROPERTY>] [<sync: SYNC>] => ;
   MESSAGE _<MessageName> [ AS <type> ] <mth> <MethodName> <export> <protect> <hidde> <persistent> <sync>

/*
 * These definitions are for backward compatibility only.
 * They are using METHOD keyword instead of MESSAGE
 * or only single local parameter in INLINED blocks.
 * If possible please do not use them and update your
 * code to use supported syntax. [druzus]
 */
#xcommand METHOD <MessageName> [ AS <type> ] VIRTUAL => ;
   MESSAGE <MessageName> [ AS <type> ] VIRTUAL
#xcommand METHOD <MessageName> [ AS <type> ] DEFERRED => ;
   MESSAGE <MessageName> [ AS <type> ] VIRTUAL
#xcommand METHOD <MessageName> [ AS <type> ] EXTERN <FuncName> [<ctor: CONSTRUCTOR>] [<export: EXPORTED, VISIBLE>] [<protect: PROTECTED>] [<hidde: HIDDEN>] [<persistent: PERSISTENT, PROPERTY>] [<sync: SYNC>] => ;
   MESSAGE <MessageName> [ AS <type> ] EXTERN <FuncName> <ctor> <export> <protect> <hidde> <persistent> <sync>
#xcommand METHOD <MessageName> [ AS <type> ] INLINE <Code,...> [LOCAL <Locals,...>] [<ctor: CONSTRUCTOR>] [<export: EXPORTED, VISIBLE>] [<protect: PROTECTED>] [<hidde: HIDDEN>] [<persistent: PERSISTENT, PROPERTY>] [<sync: SYNC>] => ;
   MESSAGE <MessageName> [ AS <type> ] [LOCAL <Locals>] INLINE <Code> <ctor> <export> <protect> <hidde> <persistent> <sync>
#xcommand METHOD <MessageName> [ AS <type> ] BLOCK <CodeBlock> [<ctor: CONSTRUCTOR>] [<export: EXPORTED, VISIBLE>] [<protect: PROTECTED>] [<hidde: HIDDEN>] [<persistent: PERSISTENT, PROPERTY>] [<sync: SYNC>] => ;
   MESSAGE <MessageName> [ AS <type> ] BLOCK <CodeBlock> <ctor> <export> <protect> <hidde> <persistent> <sync>
#xcommand METHOD <MessageName> [ AS <type> ] INLINE [LOCAL <v>] <Code,...> [<export: EXPORTED, VISIBLE>] [<protect: PROTECTED>] [<hidde: HIDDEN>] [<persistent: PERSISTENT, PROPERTY>] [<sync: SYNC>] => ;
   MESSAGE <MessageName> [ AS <type> ] [LOCAL <v>] INLINE <Code> <export> <protect> <hidde> <persistent> <sync>
#xcommand ACCESS <MessageName> [ AS <type> ] INLINE LOCAL <v> <Code,...> [<export: EXPORTED, VISIBLE>] [<protect: PROTECTED>] [<hidde: HIDDEN>] [<persistent: PERSISTENT, PROPERTY>] [<sync: SYNC>] => ;
   MESSAGE <MessageName> [ AS <type> ] LOCAL <v> INLINE <Code> <export> <protect> <hidde> <persistent> <sync>
#xcommand ASSIGN <MessageName> [ AS <type> ] INLINE LOCAL <v> <Code,...> [<export: EXPORTED, VISIBLE>] [<protect: PROTECTED>] [<hidde: HIDDEN>] [<persistent: PERSISTENT, PROPERTY>] [<sync: SYNC>] => ;
   MESSAGE _<MessageName> [ AS <type> ] LOCAL <v> INLINE <Code> <export> <protect> <hidde> <persistent> <sync>


/* Definitions of instance variables */

/* CLASSY SYNTAX */
#ifdef HB_CLS_CSY

   #xcommand CREATE CLASS <!ClassName!> [<*more*>] => CLASS <ClassName> <more>
   #xcommand END CLASS [<*more*>]   => ENDCLASS <more>
   #xcommand CLASS VAR <*more*>     => CLASSVAR <more>
   #xcommand CLASS METHOD <*more*>  => CLASSMETHOD <more>

   /* Disable the message :Class */
   #xtranslate  :CLASS  =>
   #xtranslate  :CLASS: => :

   #xtranslate _HB_MEMBER {AS Int      => _HB_MEMBER {AS Numeric
   #xtranslate _HB_MEMBER {AS Integer  => _HB_MEMBER {AS Numeric
   #xtranslate _HB_MEMBER {AS Num      => _HB_MEMBER {AS Numeric
   #xtranslate _HB_MEMBER {AS Char     => _HB_MEMBER {AS Character
   #xtranslate _HB_MEMBER {AS Block    => _HB_MEMBER {AS CodeBlock

   #xcommand EXPORTED:   =>    nScope := HB_OO_CLSTP_EXPORTED ; HB_SYMBOL_UNUSED( nScope )
   #xcommand EXPORT:     =>    nScope := HB_OO_CLSTP_EXPORTED ; HB_SYMBOL_UNUSED( nScope )
   #xcommand VISIBLE:    =>    nScope := HB_OO_CLSTP_EXPORTED ; HB_SYMBOL_UNUSED( nScope )
   #xcommand HIDDEN:     =>    nScope := HB_OO_CLSTP_HIDDEN   ; HB_SYMBOL_UNUSED( nScope )
   #xcommand PROTECTED:  =>    nScope := HB_OO_CLSTP_PROTECTED; HB_SYMBOL_UNUSED( nScope )


   /* Classy compatibility... Added By JF Lefebvre (mafact) 2006-11-07 */
   #xcommand METHOD <MethodName> [ AS <type> ] INLINE [Local <v>,] <Code,...> [<other>] => ;
             MESSAGE <MethodName> [ AS <type> ] BLOCK {|Self [,<v>] | HB_SYMBOL_UNUSED(Self), <Code>} [ <other>]

   #xcommand METHOD <MethodName>( [<params,...>] ) [ AS <type> ] INLINE [Local <v>,] <Code,...> [<other>] => ;
             MESSAGE <MethodName> [ AS <type> ] BLOCK {|Self [, <params>] [, <v>] | HB_SYMBOL_UNUSED(Self), <Code> } [ <other>]


   /* These definitions are not Class(y) compatible - I'm leaving them as is now */

   #xcommand VAR <!DataName1!> [, <!DataNameN!>] [ <tp: TYPE, AS> <type> ] [ <as: ASSIGN, INIT> <uValue> ] [<export: EXPORTED, VISIBLE>] [<protect: PROTECTED>] [<hidde: HIDDEN>] [<ro: READONLY, RO>] [<persistent: PERSISTENT, PROPERTY>] [<sync: SYNC>] => ;
      _HB_MEMBER {[ AS <type>] <DataName1> [, <DataNameN>] } ;;
      oClass:AddMultiData( <(type)>, <uValue>, __HB_CLS_SCOPE( <.export.>, <.protect.>, <.hidde.> ) + iif( <.ro.>, HB_OO_CLSTP_READONLY, 0 ) + iif( <.persistent.>, HB_OO_CLSTP_PERSIST, 0 ) + iif( <.sync.>, HB_OO_CLSTP_SYNC, 0 ), {<(DataName1)> [, <(DataNameN)>]}, __HB_CLS_NOINI )

   #xcommand VAR <!DataName!> [ AS <type> ] IN <!SuperClass!> => ;
      _HB_MEMBER {[ AS <type>] <DataName> } ;;
      oClass:AddInline( <(DataName)>, {|Self| Self:<SuperClass>:<DataName> }, HB_OO_CLSTP_EXPORTED + HB_OO_CLSTP_READONLY ) ;;
      oClass:AddInline( "_" + <(DataName)>, {|Self, param| Self:<SuperClass>:<DataName> := param }, HB_OO_CLSTP_EXPORTED )

   #xcommand VAR <!DataName!> [ AS <type> ] IS <!SprDataName!> IN <!SuperClass!> => ;
      _HB_MEMBER {[ AS <type>] <DataName> } ;;
      oClass:AddInline( <(DataName)>, {|Self| Self:<SuperClass>:<SprDataName> }, HB_OO_CLSTP_EXPORTED + HB_OO_CLSTP_READONLY ) ;;
      oClass:AddInline( "_" + <(DataName)>, {|Self, param| Self:<SuperClass>:<SprDataName> := param }, HB_OO_CLSTP_EXPORTED )

   #xcommand VAR <!DataName1!> [ AS <type> ] IS <!DataName2!> => ;
      _HB_MEMBER {[ AS <type>] <DataName1> } ;;
      oClass:AddInline( <(DataName1)>, {|Self| Self:<DataName2> }, HB_OO_CLSTP_EXPORTED + HB_OO_CLSTP_READONLY ) ;;
      oClass:AddInline( "_" + <(DataName1)>, {|Self, param| Self:<DataName2> := param }, HB_OO_CLSTP_EXPORTED )

   #xcommand VAR <!DataName1!> [ AS <type> ] IS <!DataName2!> TO <!oObject!> => ;
      _HB_MEMBER {[ AS <type>] <DataName1> } ;;
      oClass:AddInline( <(DataName1)>, {|Self| Self:<oObject>:<DataName2> }, HB_OO_CLSTP_EXPORTED + HB_OO_CLSTP_READONLY ) ;;
      oClass:AddInline( "_" + <(DataName1)>, {|Self, param| Self:<oObject>:<DataName2> := param }, HB_OO_CLSTP_EXPORTED )

#endif /* HB_CLS_CSY */

/* FWOBJECT SYNTAX */
#ifdef HB_CLS_FWO

   #xcommand DATA <!DataName1!> [, <!DataNameN!>] [ AS <type> ] [ INIT <uValue> ] [ <export: EXPORTED, VISIBLE>] [<protect: PROTECTED>] [<hidde: HIDDEN>] [<ro: READONLY, RO>] [<persistent: PERSISTENT, PROPERTY>] [<sync: SYNC>] => ;
      _HB_MEMBER {[ AS <type>] <DataName1> [, <DataNameN>] } ;;
      oClass:AddMultiData( <(type)>, <uValue>, __HB_CLS_SCOPE( <.export.>, <.protect.>, <.hidde.> ) + iif( <.ro.>, HB_OO_CLSTP_READONLY, 0 ) + iif( <.persistent.>, HB_OO_CLSTP_PERSIST, 0 ) + iif( <.sync.>, HB_OO_CLSTP_SYNC, 0 ), {<(DataName1)> [, <(DataNameN)>]}, __HB_CLS_NOINI )

   /* Warning! For backward compatibility this CLASSDATA ignores the
      SHARED clause and always create shared class variables */
   #xcommand CLASSDATA <!DataName1!> [, <!DataNameN!>] [ AS <type> ] [ INIT <uValue> ] [<export: EXPORTED, VISIBLE>] [<protect: PROTECTED>] [<hidde: HIDDEN>] [<ro: READONLY, RO>] [<share: SHARED>] [<persistent: PERSISTENT, PROPERTY>] [<sync: SYNC>] => ;
      _HB_MEMBER {[ AS <type>] <DataName1> [, <DataNameN>] } ;;
      oClass:AddMultiClsData( <(type)>, <uValue>, __HB_CLS_SCOPE( <.export.>, <.protect.>, <.hidde.> ) + iif( <.ro.>, HB_OO_CLSTP_READONLY, 0 ) + iif( /* <.share.> */ .T., HB_OO_CLSTP_SHARED, 0 ) + iif( <.persistent.>, HB_OO_CLSTP_PERSIST, 0 ) + iif( <.sync.>, HB_OO_CLSTP_SYNC, 0 ), {<(DataName1)> [, <(DataNameN)>]}, __HB_CLS_NOINI )

#endif /* HB_CLS_FWO */

/* VO SYNTAX */
#ifdef HB_CLS_VO

#ifdef HB_VO_CONSTRUCTOR
   #xtranslate  ( <!name!>{ [<p,...>] }        =>  ( <name>():New( <p> )
   #xtranslate  , <!name!>{ [<p,...>] }        =>  , <name>():New( <p> )
   #xtranslate  = <!name!>{ [<p,...>] }        =>  = <name>():New( <p> )
   #xtranslate := <!name!>{ [<p,...>] }        => := <name>():New( <p> )
#endif /* HB_VO_CONSTRUCTOR */

#xcommand EXPORT <!DataName1!> [, <!DataNameN!>] [ <tp: TYPE, AS> <type> ] [ <as: ASSIGN, INIT> <uValue> ] [<ro: READONLY, RO>] [<persistent: PERSISTENT, PROPERTY>] => ;
   _HB_MEMBER {[ AS <type>] <DataName1> [, <DataNameN>] } ;;
   oClass:AddMultiData( <(type)>, <uValue>, HB_OO_CLSTP_EXPORTED + iif( <.ro.>, HB_OO_CLSTP_READONLY, 0 ) + iif( <.persistent.>, HB_OO_CLSTP_PERSIST, 0 ), {<(DataName1)> [, <(DataNameN)>]}, __HB_CLS_NOINI )

#xcommand PROTECT <!DataName1!> [, <!DataNameN!>] [ <tp: TYPE, AS> <type> ] [ <as: ASSIGN, INIT> <uValue> ] [<ro: READONLY, RO>] [<persistent: PERSISTENT, PROPERTY>] => ;
   _HB_MEMBER {[ AS <type>] <DataName1> [, <DataNameN>] } ;;
   oClass:AddMultiData( <(type)>, <uValue>, HB_OO_CLSTP_PROTECTED + iif( <.ro.>, HB_OO_CLSTP_READONLY, 0 ) + iif( <.persistent.>, HB_OO_CLSTP_PERSIST, 0 ), {<(DataName1)> [, <(DataNameN)>]}, __HB_CLS_NOINI )

#xcommand HIDDEN <!DataName1!> [, <!DataNameN!>] [ <tp: TYPE, AS> <type> ] [ <as: ASSIGN, INIT> <uValue> ] [<ro: READONLY, RO>] [<persistent: PERSISTENT, PROPERTY>] => ;
   _HB_MEMBER {[ AS <type>] <DataName1> [, <DataNameN>] } ;;
   oClass:AddMultiData( <(type)>, <uValue>, HB_OO_CLSTP_HIDDEN + iif( <.ro.>, HB_OO_CLSTP_READONLY, 0 ) + iif( <.persistent.>, HB_OO_CLSTP_PERSIST, 0 ), {<(DataName1)> [, <(DataNameN)>]}, __HB_CLS_NOINI )

#endif /* HB_CLS_VO */

/* Xbase++ syntax */
#ifdef HB_CLS_XPP

   #xcommand SYNC METHOD <MethodName> [<decl,...>] => METHOD <MethodName> [<decl>] SYNC
   #xcommand SYNC CLASS METHOD <MethodName> [<decl,...>] => CLASSMETHOD <MethodName> [<decl>] SYNC

   #xcommand METHOD <!MethodName1!>[([<params,...>])], <!MethodName2!>[([<params,...>])] [, <!MethodNameN!>[([<params,...>])]] => ;
             METHOD <MethodName1> [ ; METHOD <MethodName2> ] [ ; METHOD <MethodNameN> ]
   #xcommand SYNC METHOD <!MethodName1!>[([<params,...>])], <!MethodName2!>[([<params,...>])] [, <!MethodNameN!>[([<params,...>])]] => ;
             SYNC METHOD <MethodName1> [ ; SYNC METHOD <MethodName2> ] [ ; SYNC METHOD <MethodNameN> ]

   /* FUNCTION/PROCEDURE is a Harbour extension */
   #xcommand METHOD [<type: FUNCTION, PROCEDURE>] <!className!>:<!methodName!>[([<params,...>])] => ;
             METHOD <type> <methodName>( <params> ) CLASS <className>

#endif /* HB_CLS_XPP */

/* Class datas and messages - we do not support real class messages yet */
#xcommand CLASSMETHOD <MethodName> [ AS <type> ] [<ctor: CONSTRUCTOR>] [<export: EXPORTED, VISIBLE>] [<protect: PROTECTED>] [<hidde: HIDDEN>] [<share: SHARED>] [<persistent: PERSISTENT, PROPERTY>] [<sync: SYNC>] => ;
   _HB_MEMBER __HB_CLS_ASFUNC(<MethodName>) [ AS <type> ];;
   __HB_CLS_DECLARE_METHOD __HB_CLS_PARAMS(<MethodName>) _CLASS_NAME_ ;;
   oClass:AddClsMethod( __HB_CLS_ASSTRING(<MethodName>), @__HB_CLS_ASID( __HB_CLS_MTHNAME _CLASS_NAME_ <MethodName> )(), __HB_CLS_SCOPE( <.export.>, <.protect.>, <.hidde.> ) + iif( <.share.>, HB_OO_CLSTP_SHARED, 0 ) + iif( <.ctor.>, HB_OO_CLSTP_CTOR, 0 ) + iif( <.persistent.>, HB_OO_CLSTP_PERSIST, 0 ) + iif( <.sync.>, HB_OO_CLSTP_SYNC, 0 ) )

#xcommand CLASSVAR <!DataName1!> [, <!DataNameN!>] [ <tp: TYPE, AS> <type> ] [ <as: ASSIGN, INIT> <uValue> ] [<export: EXPORTED, VISIBLE>] [<protect: PROTECTED>] [<hidde: HIDDEN>] [<ro: READONLY, RO>] [<share: SHARED>] [<persistent: PERSISTENT, PROPERTY>] [<sync: SYNC>] => ;
   _HB_MEMBER {[ AS <type>] <DataName1> [, <DataNameN>] } ;;
   oClass:AddMultiClsData( <(type)>, <uValue>, __HB_CLS_SCOPE( <.export.>, <.protect.>, <.hidde.> ) + iif( <.ro.>, HB_OO_CLSTP_READONLY, 0 ) + iif( <.share.>, HB_OO_CLSTP_SHARED, 0 ) + iif( <.persistent.>, HB_OO_CLSTP_PERSIST, 0 ) + iif( <.sync.>, HB_OO_CLSTP_SYNC, 0 ), {<(DataName1)> [, <(DataNameN)>]}, __HB_CLS_NOINI )


/* Scalar classes support */
#command ASSOCIATE CLASS <ClassFuncName> WITH TYPE <type: ;
   ARRAY, BLOCK, CHARACTER, DATE, HASH, LOGICAL, NIL, NUMERIC, SYMBOL, TIMESTAMP, POINTER> => ;
      __clsAssocType( __clsInstSuper( @<ClassFuncName>() ), #<type> )

#command ENABLE TYPE CLASS <type: ;
   ARRAY, BLOCK, CHARACTER, DATE, HASH, LOGICAL, NIL, NUMERIC, SYMBOL, TIMESTAMP, POINTER> ;
   [, <typeN: ;
   ARRAY, BLOCK, CHARACTER, DATE, HASH, LOGICAL, NIL, NUMERIC, SYMBOL, TIMESTAMP, POINTER>] => ;
      REQUEST HB<type> [, HB<typeN>]

#command ENABLE TYPE CLASS ALL => ;
      REQUEST HBArray, HBBlock, HBCharacter, HBDate, HBHash, ;
              HBLogical, HBNil, HBNumeric, HBSymbol, HBTimeStamp, HBPointer

#endif /* HB_CLASS_CH_ */