From 937101dd91bdc53b7559f8beffd60ed1e7a21b52 Mon Sep 17 00:00:00 2001
From: Jean-Francois Lefebvre <jfl@mafact.com>
Date: Sun, 28 May 2000 20:09:56 +0000
Subject: [PATCH] *harbour/include/hboo.ch *harbour/include/hbclass.ch  Now
 support MI, scoping, fowarding and delegating  Also support 10 chars limit by
 not prefixing the Classname when in 10 chars mode

*harbour/include/hbsetup.ch
 Allow the configuration of Hidden message

*harbour/source/rtl/objfunc.prg
 added function __objDerivedFrom(oSelf, oObj | cClassName)

*harbour/source/rtl/tclass.prg
 Major modification to implement MI & scoping
 Added message :Super to acces frist superclass object instance
 Added message :IsDerivedFrom(oObj | cClassName ) (Xbase++ comp.)

*harbour/source/vm/proc.c
  added char * hb_procname( int iLevel, char * szName )
  extracted from HB_FUNC( PROCNAME ) to allow it to be called from c
  HB_FUNC( PROCNAME ) modified to call the previous'one

*harbour/source/vm/classes.c
  Major modification to implement MI & Scoping
  Added function Sender() used by delegating to allow full polymorphism
  Added function __CLS_PARAM used by the preprocessor
---
 harbour/ChangeLog              |  30 ++
 harbour/include/hbclass.ch     | 292 +++++++++--
 harbour/include/hbextern.ch    |   8 +
 harbour/include/hboo.ch        |  31 ++
 harbour/include/hbsetup.ch     |   5 +-
 harbour/source/rtl/objfunc.prg |  25 +
 harbour/source/rtl/tclass.prg  | 232 +++++----
 harbour/source/vm/classes.c    | 889 ++++++++++++++++++++++++++++-----
 harbour/source/vm/proc.c       |  46 +-
 9 files changed, 1299 insertions(+), 259 deletions(-)

diff --git a/harbour/ChangeLog b/harbour/ChangeLog
index 11435d41c3..d9322296e1 100644
--- a/harbour/ChangeLog
+++ b/harbour/ChangeLog
@@ -1,3 +1,33 @@
+2000-05-28 22:16 UTC+0200   Jfl&RaC <jfl@mafact.com>
+
+
+*harbour/include/hboo.ch
+*harbour/include/hbclass.ch
+ Now support MI, scoping, fowarding and delegating
+ Also support 10 chars limit by not prefixing the Classname when in 10 chars mode
+
+*harbour/include/hbsetup.ch
+ Allow the configuration of Hidden message
+
+*harbour/source/rtl/objfunc.prg
+ added function __objDerivedFrom(oSelf, oObj | cClassName)
+
+*harbour/source/rtl/tclass.prg
+ Major modification to implement MI & scoping
+ Added message :Super to acces frist superclass object instance
+ Added message :IsDerivedFrom(oObj | cClassName ) (Xbase++ comp.)
+
+*harbour/source/vm/proc.c
+ added char * hb_procname( int iLevel, char * szName )
+ extracted from HB_FUNC( PROCNAME ) to allow it to be called from c
+ HB_FUNC( PROCNAME ) modified to call the previous'one
+
+*harbour/source/vm/classes.c
+ Major modification to implement MI & Scoping
+ Added function Sender() used by delegating to allow full polymorphism
+ Added function __CLS_PARAM used by the preprocessor
+
+
 2000-05-27 23:12 UTC+0100 Victor Szakats <info@szelvesz.hu>
 
    * source/rtl/gtdos/gtdos.c
diff --git a/harbour/include/hbclass.ch b/harbour/include/hbclass.ch
index 09925b0f9e..8c01592a77 100644
--- a/harbour/include/hbclass.ch
+++ b/harbour/include/hbclass.ch
@@ -6,6 +6,10 @@
  * Harbour Project source code:
  * Header file for Class commands
  *
+ *
+ * Copyright 2000 JfL&RaC <jflefebv@mafact.com>
+ * www - http://www.harbour-project.org
+ *
  * Copyright 1999 Antonio Linares <alinares@fivetech.com>
  * www - http://www.harbour-project.org
  *
@@ -37,6 +41,13 @@
  * The following parts are Copyright of the individual authors.
  * www - http://www.harbour-project.org
  *
+ *
+ * Copyright 2000 JF Lefebvre <jfl@mafact.com> and RA Cuylen <rac@mafact.com>
+ *    Support for Class(y), TopClass and Visual Object compatibility
+ *    Support for MI, Scoping (Protect, Hidden and Readonly)
+ *    Delegating, DATA Shared
+ *    Support of 10 Chars limits
+ *
  * Copyright 2000 Brian Hays <bhays@abacuslaw.com>
  *    Documentation for the commands
  *
@@ -44,69 +55,245 @@
  *
  */
 
+#include "hbsetup.ch"
+
+#ifndef HB_OO_CH_
+ #include "hboo.ch"
+#endif
+
 #ifndef HB_CLASS_CH_
 #define HB_CLASS_CH_
 
-#xcommand CLASS <ClassName> [ <frm: FROM, INHERIT> <SuperClass> ] => ;
-   function <ClassName>() ;;
+#xtranslate HBCLSCHOICE( <export>, <protect>, <hidde> ) => if( <export>, HBCLSTP_EXPORTED , if( <protect>, HBCLSTP_PROTECTED, if( <hidde>, HBCLSTP_HIDDEN, nScope) ) )
+
+#xtranslate CREATE CLASS => CLASS
+
+
+#ifndef HB_SHORTNAMES
+#xcommand CLASS <ClassName> [ <frm: FROM, INHERIT> <SuperClass1> [,<SuperClassN>] ] [<static: STATIC>] => ;
+   <static> function <ClassName>() ;;
       static oClass ;;
+      local nScope := HBCLSTP_EXPORTED ;;
       if oClass == nil ;;
-         oClass := TClass():New( <(ClassName)> [,<(SuperClass)>] ) ;;
+         oClass := TClass():New( <(ClassName)>, __CLS_PARAM([ <(SuperClass1)> ] [ ,<(SuperClassN)> ] ) ) ;;
      #undef _CLASS_NAME_ ;;
      #define _CLASS_NAME_ <ClassName> ;;
      #translate CLSMETH <ClassName> <MethodName>() => @<ClassName>_<MethodName>() ;
-     [ ; #translate Super : => ::<SuperClass>: ] ;
-     [ ; extern <SuperClass> ]
+     [ ; #translate Super( <SuperClassN> ) : => ::<SuperClassN>: ] ;
+     [ ; #translate Super( <SuperClass1> ) : => ::<SuperClass1>: ] ;
+     [ ; #translate Super() : => ::<SuperClass1>: ] ;
+     [ ; #translate Super : => ::<SuperClass1>: ] ;
+     [ ; extern <SuperClass1> ] [ ,<SuperClassN> ]
+#else
+#xcommand CLASS <ClassName> [ <frm: FROM, INHERIT> <SuperClass1> [,<SuperClassN>] ] [<static: STATIC>] => ;
+   <static> function <ClassName>() ;;
+      static oClass ;;
+      local nScope := HBCLSTP_EXPORTED ;;
+      if oClass == nil ;;
+         oClass := TClass():New( <(ClassName)>, __CLS_PARAM([ <(SuperClass1)> ] [ ,<(SuperClassN)> ] ) ) ;;
+     #undef _CLASS_NAME_ ;;
+     #define _CLASS_NAME_ <ClassName> ;;
+     #translate CLSMETH <ClassName> <MethodName>() => @<MethodName>() ;
+     [ ; #translate Super( <SuperClassN> ) : => ::<SuperClassN>: ] ;
+     [ ; #translate Super( <SuperClass1> ) : => ::<SuperClass1>: ] ;
+     [ ; #translate Super() : => ::<SuperClass1>: ] ;
+     [ ; #translate Super : => ::<SuperClass1>: ] ;
+     [ ; extern <SuperClass1> ] [ ,<SuperClassN> ]
+#endif /* HB_SHORTNAMES */
 
+//VO compatibility
+#xtranslate  ( <name>{ [<p,...>] }        =>  ( <name>():New( <p> )
+#xtranslate := <name>{ [<p,...>] }        => := <name>():New( <p> )
+#xtranslate  = <name>{ [<p,...>] }        =>  = <name>():New( <p> )
+#xtranslate  , <name>{ [<p,...>] }        =>  , <name>():New( <p> )
 
-/* Note the use of commas ',' on the following rule to avoid their call
-   if there are no AS ... or INIT clauses specified. As we just use
-   those methods first parameter, the second one supplied acts as a dummy one */
+#xtranslate    EXPORTED:       =>      nScope := HBCLSTP_EXPORTED
+#xtranslate    VISIBLE:        =>      nScope := HBCLSTP_EXPORTED
+#xtranslate    HIDDEN:         =>      nScope := HBCLSTP_HIDDEN
+#xtranslate    PROTECTED:      =>      nScope := HBCLSTP_PROTECTED
 
-#xcommand DATA <DataName1> [,<DataNameN>] [ AS <type> ] [ INIT <uValue> ] => ;
-   [ oClass:SetType( <(type)> ) ; ][ oClass:SetInit( <uValue> ) ; ] ;
-     oClass:AddData( <(DataName1)> ) ;
-   [; oClass:AddData( <(DataNameN)> ) ] ;
-   [; oClass:SetInit(,<uValue>) ] [ ; oClass:SetType(,<(type)>) ]
+#xcommand DATA <DataNames,...> [ AS <type> ] [ INIT <uValue> ] [ <export: EXPORTED, VISIBLE>] [<protect: PROTECTED>] [<hidde: HIDDEN>] [<ro: READONLY, RO>] => ;
+     oClass:AddMultiData( <(type)>, <uValue>, HBCLSCHOICE( <.export.>, <.protect.>, <.hidde.> ) + if( <.ro.>, HBCLSTP_READONLY, 0 ), \{<(DataNames)>\} ) ;
 
-/* Note the use of commas ',' on the following rule to avoid their call
-   if there are no AS ... or INIT clauses specified. As we just use
-   those methods first parameter, the second one supplied acts as a dummy one */
+#xcommand VAR <DataNames,...> [ TYPE <type> ] [ ASSIGN <uValue> ] [<export: EXPORTED, VISIBLE>] [<protect: PROTECTED>] [<hidde: HIDDEN>] [<ro: READONLY, RO>] => ;
+     oClass:AddMultiData( <(type)>, <uValue>, HBCLSCHOICE( <.export.>, <.protect.>, <.hidde.> ) + if( <.ro.>, HBCLSTP_READONLY, 0 ), \{<(DataNames)>\} ) ;
 
-#xcommand CLASSDATA <DataName1> [,<DataNameN>] [ AS <type> ] [ INIT <uValue> ] => ;
-   [ oClass:SetType( <(type)> ) ; ][ oClass:SetInit( <uValue> ) ; ] ;
-     oClass:AddClassData( <(DataName1)> ) ;
-   [; oClass:AddClassData( <(DataNameN)> ) ] ;
-   [; oClass:SetInit(,<uValue>) ] [ ; oClass:SetType(,<(type)>) ]
+#xcommand VAR <DataNames,...> [ AS <type> ] [ INIT <uValue> ] [<export: EXPORTED, VISIBLE>] [<protect: PROTECTED>] [<hidde: HIDDEN>] [<ro: READONLY, RO>] => ;
+     oClass:AddMultiData( <(type)>, <uValue>, HBCLSCHOICE( <.export.>, <.protect.>, <.hidde.> ) + if( <.ro.>, HBCLSTP_READONLY, 0 ), \{<(DataNames)>\} ) ;
 
-#xcommand METHOD <MethodName>( [<params,...>] ) [ CONSTRUCTOR ] => ;
-   oClass:AddMethod( <(MethodName)>, CLSMETH _CLASS_NAME_ <MethodName>() )
+#xcommand VAR <DataName> IN <SuperClass> => ;
+     oClass:AddInline( <(DataName)>, {|Self| Self:<SuperClass>:<DataName> }, HBCLSTP_EXPORTED + HBCLSTP_READONLY ) ;;
+     oClass:AddInline( "_" + <(DataName)>, {|Self, param| Self:<SuperClass>:<DataName> := param }, HBCLSTP_EXPORTED )
 
-#xcommand METHOD <MethodName>( [<params,...>] ) BLOCK <CodeBlock> => ;
-   oClass:AddInline( <(MethodName)>, <CodeBlock> )
+#xcommand VAR <DataName> IS <SprDataName> IN <SuperClass> => ;
+     oClass:AddInline( <(DataName)>, {|Self| Self:<SuperClass>:<SprDataName> }, HBCLSTP_EXPORTED + HBCLSTP_READONLY ) ;;
+     oClass:AddInline( "_" + <(DataName)>, {|Self, param| Self:<SuperClass>:<SprDataName> := param }, HBCLSTP_EXPORTED )
 
-#xcommand METHOD <MethodName>( [<params,...>] ) EXTERN <FuncName>( [<params,...>] ) => ;
-   oClass:AddMethod( <(MethodName)>, @<FuncName>() )
+#xcommand VAR <DataName1> IS <DataName2> => ;
+     oClass:AddInline( <(DataName1)>, {|Self| Self:<DataName2> }, HBCLSTP_EXPORTED + HBCLSTP_READONLY ) ;;
+     oClass:AddInline( "_" + <(DataName1)>, {|Self, param| Self:<DataName2> := param }, HBCLSTP_EXPORTED )
 
-#xcommand METHOD <MethodName>( [<params,...>] ) INLINE <Code,...> => ;
-   oClass:AddInline( <(MethodName)>, {|Self [,<params>] | <Code> } )
+#xcommand VAR <DataName1> IS <DataName2> TO <oObject> => ;
+     oClass:AddInline( <(DataName1)>, {|Self| Self:<oObject>:<DataName2> }, HBCLSTP_EXPORTED + HBCLSTP_READONLY ) ;;
+     oClass:AddInline( "_" + <(DataName1)>, {|Self, param| Self:<oObject>:<DataName2> := param }, HBCLSTP_EXPORTED )
+
+#xcommand EXPORT <DataNames,...> [ AS <type> ] [ INIT <uValue> ] [<ro: READONLY, RO>] => ;
+     oClass:AddMultiData( <(type)>, <uValue>, HBCLSTP_EXPORTED + if( <.ro.>, HBCLSTP_READONLY, 0 ), \{<(DataNames)>\} ) ;
+
+#xcommand EXPORT <DataNames,...> [ TYPE <type> ] [ ASSIGN <uValue> ] [<ro: READONLY, RO>] => ;
+     oClass:AddMultiData( <(type)>, <uValue>, HBCLSTP_EXPORTED + if( <.ro.>, HBCLSTP_READONLY, 0 ), \{<(DataNames)>\} ) ;
+
+#xcommand PROTECT <DataNames,...> [ AS <type> ] [ INIT <uValue> ] [<ro: READONLY, RO>] => ;
+     oClass:AddMultiData( <(type)>, <uValue>, HBCLSTP_PROTECTED + if( <.ro.>, HBCLSTP_READONLY, 0 ), \{<(DataNames)>\} ) ;
+
+#xcommand PROTECT <DataNames,...> [ TYPE <type> ] [ ASSIGN <uValue> ] [<ro: READONLY, RO>] => ;
+     oClass:AddMultiData( <(type)>, <uValue>, HBCLSTP_PROTECTED + if( <.ro.>, HBCLSTP_READONLY, 0 ), \{<(DataNames)>\} ) ;
+
+#xcommand HIDDE <DataNames,...> [ AS <type> ] [ INIT <uValue> ] [<ro: READONLY, RO>] => ;
+     oClass:AddMultiData( <(type)>, <uValue>, HBCLSTP_HIDDEN + if( <.ro.>, HBCLSTP_READONLY, 0 ), \{<(DataNames)>\} ) ;
+
+#xcommand HIDDE <DataNames,...> [ TYPE <type> ] [ ASSIGN <uValue> ] [<ro: READONLY, RO>] => ;
+     oClass:AddMultiData( <(type)>, <uValue>, HBCLSTP_HIDDEN + if( <.ro.>, HBCLSTP_READONLY, 0 ), \{<(DataNames)>\} ) ;
+
+#xcommand CLASSDATA <DataNames,...> [ AS <type> ] [ INIT <uValue> ] [<export: EXPORTED, VISIBLE>] [<protect: PROTECTED>] [<hidde: HIDDEN>] [<ro: READONLY, RO>] [<share: SHARED>] => ;
+     oClass:AddMultiClsData(<(type)>, <uValue>, HBCLSCHOICE( <.export.>, <.protect.>, <.hidde.> ) + if( <.ro.>, HBCLSTP_READONLY, 0 ) + if( <.share.>, HBCLSTP_SHARED, 0 ), \{<(DataNames)>\} ) ;
+
+#xtranslate CLASS VAR => CLASSVAR
+
+#xcommand CLASSVAR <DataNames,...> [ TYPE <type> ] [ ASSIGN <uValue> ] [<export: EXPORTED, VISIBLE>] [<protect: PROTECTED>] [<hidde: HIDDEN>] [<ro: READONLY, RO>] [<share: SHARED>] => ;
+     oClass:AddMultiClsData(<(type)>, <uValue>, HBCLSCHOICE( <.export.>, <.protect.>, <.hidde.> ) + if( <.ro.>, HBCLSTP_READONLY, 0 ) + if( <.share.>, HBCLSTP_SHARED, 0 ), \{<(DataNames)>\} ) ;
+
+#xcommand CLASSVAR <DataNames,...> [ AS <type> ] [ INIT <uValue> ] [<export: EXPORTED, VISIBLE>] [<protect: PROTECTED>] [<hidde: HIDDEN>] [<ro: READONLY, RO>] [<share: SHARED>] => ;
+     oClass:AddMultiClsData(<(type)>, <uValue>, HBCLSCHOICE( <.export.>, <.protect.>, <.hidde.> ) + if( <.ro.>, HBCLSTP_READONLY, 0 ) + if( <.share.>, HBCLSTP_SHARED, 0 ), \{<(DataNames)>\} ) ;
+
+#xtranslate CLASS METHOD => CLASSMETHOD
+
+#xcommand CLASSMETHOD <MethodName> [<export: EXPORTED, VISIBLE>] [<protect: PROTECTED>] [<hidde: HIDDEN>] [<share: SHARED>] => ;
+   oClass:AddClsMthds( <(MethodName)>, CLSMETH _CLASS_NAME_ <MethodName>(), HBCLSCHOICE( <.export.>, <.protect.>, <.hidde.> ) + if( <.share.>, HBCLSTP_SHARED, 0 ) )
+
+#xcommand CLASSMETHOD <MethodName>() [<export: EXPORTED, VISIBLE>] [<protect: PROTECTED>] [<hidde: HIDDEN>] [<share: SHARED>] => ;
+   oClass:AddClsMthds( <(MethodName)>, CLSMETH _CLASS_NAME_ <MethodName>(), HBCLSCHOICE( <.export.>, <.protect.>, <.hidde.> ) + if( <.share.>, HBCLSTP_SHARED, 0 ) )
+
+#xcommand CLASSMETHOD <MethodName>( [<params,...>] ) [<export: EXPORTED, VISIBLE>] [<protect: PROTECTED>] [<hidde: HIDDEN>] [<share: SHARED>] => ;
+   oClass:AddClsMthds( <(MethodName)>, CLSMETH _CLASS_NAME_ <MethodName>(), HBCLSCHOICE( <.export.>, <.protect.>, <.hidde.> ) + if( <.share.>, HBCLSTP_SHARED, 0 ) )
+
+#xcommand CONSTRUCTOR <Name>( [<params,...>] ) => METHOD <Name>( [<params,...>] ) CONSTRUCTOR
+
+//Oups to verify that the word new is not reserved...
+//#xcommand CONSTRUCTOR New( [<params,...>] ) => METHOD New( [<params,...>] ) CONSTRUCTOR
+
+#xcommand METHOD <MethodName> [ <ctor: CONSTRUCTOR> ] [ <export: EXPORTED, VISIBLE>] [<protect: PROTECTED>] [<hidde: HIDDEN>] => ;
+   oClass:AddMethod( <(MethodName)>, CLSMETH _CLASS_NAME_ <MethodName>(), HBCLSCHOICE( <.export.>, <.protect.>, <.hidde.> ) + if( <.ctor.>, HBCLSTP_CTOR, 0 ) )
+
+#xcommand METHOD <MethodName>( [<params,...>] ) [ <ctor: CONSTRUCTOR> ] [ <export: EXPORTED, VISIBLE>] [<protect: PROTECTED>] [<hidde: HIDDEN>] => ;
+   oClass:AddMethod( <(MethodName)>, CLSMETH _CLASS_NAME_ <MethodName>(), HBCLSCHOICE( <.export.>, <.protect.>, <.hidde.> ) + if( <.ctor.>, HBCLSTP_CTOR, 0 ) )
+
+#xcommand METHOD <MethodName> BLOCK <CodeBlock> [ <ctor: CONSTRUCTOR> ] [ <export: EXPORTED, VISIBLE>] [<protect: PROTECTED>] [<hidde: HIDDEN>] => ;
+   oClass:AddInline( <(MethodName)>, <CodeBlock>, HBCLSCHOICE( <.export.>, <.protect.>, <.hidde.> ) + if( <.ctor.>, HBCLSTP_CTOR, 0 ) )
+
+#xcommand METHOD <MethodName>( [<params,...>] ) BLOCK <CodeBlock> [ <ctor: CONSTRUCTOR> ] [ <export: EXPORTED, VISIBLE>] [<protect: PROTECTED>] [<hidde: HIDDEN>] => ;
+   oClass:AddInline( <(MethodName)>, <CodeBlock>, HBCLSCHOICE( <.export.>, <.protect.>, <.hidde.> ) + if( <.ctor.>, HBCLSTP_CTOR, 0 ) )
+
+#xcommand METHOD <MethodName>( [<params,...>] ) EXTERN <FuncName>( [<params,...>] ) [ <ctor: CONSTRUCTOR> ] [ <export: EXPORTED, VISIBLE>] [<protect: PROTECTED>] [<hidde: HIDDEN>] => ;
+   oClass:AddMethod( <(MethodName)>, @<FuncName>(), HBCLSCHOICE( <.export.>, <.protect.>, <.hidde.> ) + if( <.ctor.>, HBCLSTP_CTOR, 0 ) )
+
+#xcommand METHOD <MethodName> INLINE <Code,...> [ <ctor: CONSTRUCTOR> ] [ <export: EXPORTED, VISIBLE>] [<protect: PROTECTED>] [<hidde: HIDDEN>] => ;
+   oClass:AddInline( <(MethodName)>, {|Self | <Code> }, HBCLSCHOICE( <.export.>, <.protect.>, <.hidde.> ) + if( <.ctor.>, HBCLSTP_CTOR, 0 ) )
+
+#xcommand METHOD <MethodName>( [<params,...>] ) INLINE <Code,...> [ <ctor: CONSTRUCTOR> ] [ <export: EXPORTED, VISIBLE>] [<protect: PROTECTED>] [<hidde: HIDDEN>] => ;
+   oClass:AddInline( <(MethodName)>, {|Self [,<params>] | <Code> }, HBCLSCHOICE( <.export.>, <.protect.>, <.hidde.> ) + if( <.ctor.>, HBCLSTP_CTOR, 0 ) )
+
+#xcommand METHOD <MethodName> INLINE [Local <v>,] <Code,...> [<other>] => ;
+          METHOD <MethodName> BLOCK {|Self [,<v>] | <Code> } [<other>]
+
+#xcommand METHOD <MethodName>( [<params,...>] ) INLINE [Local <v>,] <Code,...> [<other>] => ;
+          METHOD <MethodName> BLOCK {|Self [,<params>] [,<v>] | <Code> } [<other>]
+
+#xcommand METHOD <MethodName> DEFERRED => ;
+   oClass:AddVirtual( <(MethodName)> )
+
+#xcommand METHOD <MethodName>( [<params,...>] ) DEFERRED => ;
+   oClass:AddVirtual( <(MethodName)> )
 
 #xcommand METHOD <MethodName>( [<params,...>] ) VIRTUAL => ;
    oClass:AddVirtual( <(MethodName)> )
 
+#xcommand METHOD <MethodName>( [<params>] ) OPERATOR <op> [ <export: EXPORTED, VISIBLE>] [<protect: PROTECTED>] [<hidde: HIDDEN>] => ;
+   oClass:AddMethod( <(MethodName)>, CLSMETH _CLASS_NAME_ <MethodName>(), HBCLSCHOICE( <.export.>, <.protect.>, <.hidde.> ) ) ;;
+   oClass:AddInline( <(op)>, {|Self [,<params>] | Self:<MethodName>( [<params>] ) }, HBCLSCHOICE( <.export.>, <.protect.>, <.hidde.> ) )
+
+#xcommand MESSAGE <MessageName> METHOD <MethodName> [ <ctor: CONSTRUCTOR> ] [ <export: EXPORTED, VISIBLE>] [<protect: PROTECTED>] [<hidde: HIDDEN>] => ;
+   oClass:AddMethod( <(MessageName)>, CLSMETH _CLASS_NAME_ <MethodName>(), HBCLSCHOICE( <.export.>, <.protect.>, <.hidde.> ) + if( <.ctor.>, HBCLSTP_CTOR, 0 ) )
+
+#xcommand MESSAGE <MessageName> METHOD <MethodName>( [<params,...>] ) [ <ctor: CONSTRUCTOR> ] [ <export: EXPORTED, VISIBLE>] [<protect: PROTECTED>] [<hidde: HIDDEN>]=> ;
+   oClass:AddMethod( <(MessageName)>, CLSMETH _CLASS_NAME_ <MethodName>(), HBCLSCHOICE( <.export.>, <.protect.>, <.hidde.> ) + if( <.ctor.>, HBCLSTP_CTOR, 0 ) )
+
+#xcommand MESSAGE <MessageName>( [<params,...>] ) METHOD <MethodName> [ <ctor: CONSTRUCTOR> ] [ <export: EXPORTED, VISIBLE>] [<protect: PROTECTED>] [<hidde: HIDDEN>] => ;
+   oClass:AddMethod( <(MessageName)>, CLSMETH _CLASS_NAME_ <MethodName>(), HBCLSCHOICE( <.export.>, <.protect.>, <.hidde.> ) + if( <.ctor.>, HBCLSTP_CTOR, 0 ) )
+
+#xcommand MESSAGE <MessageName>( [<params,...>] ) METHOD <MethodName>( [<dummy,...>] ) [ <ctor: CONSTRUCTOR> ] [ <export: EXPORTED, VISIBLE>] [<protect: PROTECTED>] [<hidde: HIDDEN>] => ;
+   oClass:AddMethod( <(MessageName)>, CLSMETH _CLASS_NAME_ <MethodName>(), HBCLSCHOICE( <.export.>, <.protect.>, <.hidde.> ) + if( <.ctor.>, HBCLSTP_CTOR, 0 ) )
+
+#xcommand MESSAGE <MessageName> IN <SuperClass> => ;
+     oClass:AddInline( <(MessageName)>, {|Self| Self:<SuperClass>:<MessageName>() } )
+
+#xcommand MESSAGE <MessageName>( [<params,...>] ) IN <SuperClass> => ;
+     oClass:AddInline( <(MessageName)>, {|Self [,<params>]| Self:<SuperClass>:<MessageName>( [<params>] ) } )
+
+#xcommand MESSAGE <MessageName> IS <SprMethodName> IN <SuperClass> => ;
+     oClass:AddInline( <(MessageName)>, {|Self| Self:<SuperClass>:<SprMethodName>() } )
+
+#xcommand MESSAGE <MessageName> IS <SprMethodName>( [<params,...>] ) IN <SuperClass> => ;
+     oClass:AddInline( <(MessageName)>, {|Self [,<params>]| Self:<SuperClass>:<SprMethodName>( [<params>] ) } )
+
+#xcommand MESSAGE <MessageName>( [<params,...>] ) IS <SprMethodName> IN <SuperClass> => ;
+     oClass:AddInline( <(MessageName)>, {|Self [,<params>]| Self:<SuperClass>:<SprMethodName>( [<params>] ) } )
+
+#xcommand MESSAGE <MessageName>( [<params,...>] ) IS <SprMethodName>( [<dummy,...>] ) IN <SuperClass> => ;
+     oClass:AddInline( <(MessageName)>, {|Self [,<params>]| Self:<SuperClass>:<SprMethodName>( [<params>] ) } )
+
+#xcommand MESSAGE <MessageName> IS <MethodName> [ <ctor: CONSTRUCTOR> ] [ <export: EXPORTED, VISIBLE>] [<protect: PROTECTED>] [<hidde: HIDDEN>] => ;
+   oClass:AddMethod( <(MessageName)>, CLSMETH _CLASS_NAME_ <MethodName>(), HBCLSCHOICE( <.export.>, <.protect.>, <.hidde.> ) + if( <.ctor.>, HBCLSTP_CTOR, 0 ) )
+
+#xcommand MESSAGE <MessageName> IS <MethodName>( [<params,...>] ) [ <ctor: CONSTRUCTOR> ] [ <export: EXPORTED, VISIBLE>] [<protect: PROTECTED>] [<hidde: HIDDEN>]=> ;
+   oClass:AddMethod( <(MessageName)>, CLSMETH _CLASS_NAME_ <MethodName>(), HBCLSCHOICE( <.export.>, <.protect.>, <.hidde.> ) + if( <.ctor.>, HBCLSTP_CTOR, 0 ) )
+
+#xcommand MESSAGE <MessageName>( [<params,...>] ) IS <MethodName> [ <ctor: CONSTRUCTOR> ] [ <export: EXPORTED, VISIBLE>] [<protect: PROTECTED>] [<hidde: HIDDEN>] => ;
+   oClass:AddMethod( <(MessageName)>, CLSMETH _CLASS_NAME_ <MethodName>(), HBCLSCHOICE( <.export.>, <.protect.>, <.hidde.> ) + if( <.ctor.>, HBCLSTP_CTOR, 0 ) )
+
+#xcommand MESSAGE <MessageName>( [<params,...>] ) IS <MethodName>( [<dummy,...>] ) [ <ctor: CONSTRUCTOR> ] [ <export: EXPORTED, VISIBLE>] [<protect: PROTECTED>] [<hidde: HIDDEN>] => ;
+   oClass:AddMethod( <(MessageName)>, CLSMETH _CLASS_NAME_ <MethodName>(), HBCLSCHOICE( <.export.>, <.protect.>, <.hidde.> ) + if( <.ctor.>, HBCLSTP_CTOR, 0 ) )
+
+#xcommand MESSAGE <MessageName> TO <oObject> =>;
+   oClass:AddInline( <(MessageName)>, {|Self| Self:<oObject>:<MessageName> } )
+
+#xcommand MESSAGE <MessageName>( [<params,...>] ) TO <oObject> =>;
+   oClass:AddInline( <(MessageName)>, {|Self [,<params>]| Self:<oObject>:<MessageName>( [<params>] ) } )
+
+#xcommand DELEGATE <MessageName> TO <oObject> =>;
+   oClass:AddInline( <(MessageName)>, {|Self| Self:<oObject>:<MessageName> } )
+
+#xcommand DELEGATE <MessageName>( [<params,...>] ) TO <oObject> =>;
+   oClass:AddInline( <(MessageName)>, {|Self [,<params>]| Self:<oObject>:<MessageName>( [<params>] ) } )
+
 #xcommand METHOD <MethodName>( [<params,...>] ) SETGET => ;
-   oClass:AddMethod( <(MethodName)>, CLSMETH _CLASS_NAME_ <MethodName>() ) ;;
-   oClass:AddMethod( "_" + <(MethodName)>, CLSMETH _CLASS_NAME_ <MethodName>() )
+   oClass:AddMethod( <(MethodName)>, CLSMETH _CLASS_NAME_ <MethodName>(), HBCLSTP_EXPORTED + HBCLSTP_READONLY ) ;;
+   oClass:AddMethod( _<(MethodName)>, CLSMETH _CLASS_NAME_ _<MethodName>() )
 
-#xcommand METHOD <MethodName>( [<param>] ) OPERATOR <op> => ;
-   oClass:AddMethod( <(MethodName)>, CLSMETH _CLASS_NAME_ <MethodName>() ) ;;
-   oClass:AddInline( <(op)>, {|Self [,<param>] | ::<MethodName>( [<param>] ) } )
+#xcommand ACCESS <AccessName> => ;
+   oClass:AddMethod( <(AccessName)>, CLSMETH _CLASS_NAME_ <AccessName>(), HBCLSTP_EXPORTED + HBCLSTP_READONLY )
 
-#xcommand MESSAGE <MessageName> METHOD <MethodName>( [<params,...>] ) => ;
-   oClass:AddMethod( <(MessageName)>, CLSMETH _CLASS_NAME_ <MethodName>() )
+#xcommand ACCESS <AccessName> INLINE [Local <v>,] <code,...> => ;
+   oClass:AddInline( <(AccessName)>, {|Self [,<v>] | <code> }, HBCLSTP_EXPORTED + HBCLSTP_READONLY )
 
-#xcommand MESSAGE <MessageName>() METHOD <MethodName>( [<params,...>] ) => ;
-   oClass:AddMethod( <(MessageName)>, CLSMETH _CLASS_NAME_ <MethodName>() )
+#xcommand ACCESS <AccessName> DEFERRED => ;
+   oClass:AddVirtual( <(AccessName)> )
+
+#xcommand ASSIGN <AssignName>( [<params,...>] ) => ;
+   oClass:AddMethod( "_" + <(AssignName)>, CLSMETH _CLASS_NAME_ _<AssignName>(), HBCLSTP_EXPORTED )
+
+#xcommand ASSIGN <AssignName>( [<params,...>] ) INLINE [Local <v>,] <Code,...> => ;
+   oClass:AddInline( "_" + <(AssignName)>, {|Self [,<params>] [,<v>] | <Code> }, HBCLSTP_EXPORTED )
 
 #xcommand ERROR HANDLER <MethodName>( [<params,...>] ) => ;
    oClass:SetOnError( CLSMETH _CLASS_NAME_ <MethodName>() )
@@ -114,14 +301,39 @@
 #xcommand ON ERROR <MethodName>( [<params,...>] ) => ;
    oClass:SetOnError( CLSMETH _CLASS_NAME_ <MethodName>() )
 
+#xtranslate END CLASS => ENDCLASS
+
 #xcommand ENDCLASS => oClass:Create() ;;
                       endif ;;
                       return oClass:Instance()
 
-#xcommand END CLASS => ENDCLASS
+#xtranslate :Super( <SuperClass> ) : => :<SuperClass>:
+#xtranslate :Super() : => :Super:
+#xtranslate :Super() => :Super
 
+#ifndef HB_SHORTNAMES
 #xcommand METHOD <MethodName>( [<params,...>] ) CLASS <ClassName> => ;
           static function <ClassName>_<MethodName>( [<params>] ) ;;
           local Self := QSelf()
 
-#endif /* HB_CLASS_CH_ */
\ No newline at end of file
+#xcommand ACCESS <AccessName>() CLASS <ClassName> => ;
+          static function <ClassName>_<AccessName>() ;;
+          local Self := QSelf()
+
+#xcommand ASSIGN <AssignName>( [<params,...>] ) CLASS <ClassName> => ;
+          static function <ClassName>__<AssignName>( [<params>] ) ;;
+          local Self := QSelf()
+#else
+#xcommand METHOD <MethodName>( [<params,...>] ) CLASS <ClassName> => ;
+          static function <MethodName>( [<params>] ) ;;
+          local Self := QSelf()
+
+#xcommand ACCESS <AccessName>() CLASS <ClassName> => ;
+          static function <AccessName>() ;;
+          local Self := QSelf()
+
+#xcommand ASSIGN <AssignName>( [<params,...>] ) CLASS <ClassName> => ;
+          static function _<AssignName>( [<params>] ) ;;
+          local Self := QSelf()
+#endif /* HB_SHORTNAMES */
+#endif /* HB_CLASS_CH_ */
diff --git a/harbour/include/hbextern.ch b/harbour/include/hbextern.ch
index a4146aaee7..6c74685ece 100644
--- a/harbour/include/hbextern.ch
+++ b/harbour/include/hbextern.ch
@@ -6,6 +6,10 @@
  * Harbour Project source code:
  * The declarations for all harbour defined functions/procedures.
  *
+ *
+ * Copyright 2000 J. Lefebvre <jfl@mafact.com> & RA. Cuylen <rac@mafact.com>
+ * www - http://www.harbour-project.org
+ *
  * Copyright 1999 Ryszard Glab <rglab@imid.med.pl>
  * www - http://www.harbour-project.org
  *
@@ -81,6 +85,9 @@ EXTERNAL __CLASSADD
 EXTERNAL __CLASSNAME
 EXTERNAL __CLASSSEL
 EXTERNAL __GETMESSAGE
+EXTERNAL __CLS_PARAM //Added by RaC&JfL
+EXTERNAL __CLSPARENT //Added by RaC&JfL
+EXTERNAL SENDER      //Added by RaC&JfL
 //
 //symbols from file: vm\cmdarg.c
 //
@@ -642,6 +649,7 @@ EXTERNAL __OBJMODINLINE
 EXTERNAL __OBJDELMETHOD
 EXTERNAL __OBJDELINLINE
 EXTERNAL __OBJDELDATA
+EXTERNAL __OBJDERIVEDFROM //Added by RaC&JfL
 //
 //symbols from file: rtl\readkey.prg
 //
diff --git a/harbour/include/hboo.ch b/harbour/include/hboo.ch
index 3b032b9b26..80ffa589dc 100644
--- a/harbour/include/hboo.ch
+++ b/harbour/include/hboo.ch
@@ -6,6 +6,9 @@
  * Harbour Project source code:
  * Header file for low-level object engine
  *
+ * Copyright 2000 J. Lefebvre <jfl@mafact.com> & RA. Cuylen <rac@mafact.com>
+ * www - http://www.harbour-project.org
+ *
  * Copyright 1999 Victor Szakats <info@szelvesz.hu>
  * www - http://www.harbour-project.org
  *
@@ -38,6 +41,19 @@
 #ifndef HB_OO_CH_
 #define HB_OO_CH_
 
+//Added by RAC&JF
+/* Method or Data attribute (nScope)*/
+#define HBCLSTP_EXPORTED        1 // No comment, default
+#define HBCLSTP_PROTECTED       2 // Only usable from one of the object's method (even sublclassed object)
+#define HBCLSTP_HIDDEN          4 // Only usable from one of the object's method (and not from sublclassed one)
+#define HBCLSTP_CTOR            8 // Constructor  (Not yet used)
+#define HBCLSTP_READONLY       16 // No comment
+#define HBCLSTP_SHARED         32 // Allow a classvar (or classmethod) to be shared by all the subclasses.
+                                  // Not the default behaviour as each subclass will have its own copy by default.
+#define HBCLSTP_CLASS          64 // The related message is a superobject call, uidata is the superclass handle
+                                  // pInitValue contain one superclass object instance (absolutely needed for Inline msg and class data)
+#define HBCLSTP_SUPER         128 // The related message is inherited from a superclass
+
 /* Message types */
 #define HB_OO_MSG_METHOD        0
 #define HB_OO_MSG_DATA          1
@@ -46,14 +62,29 @@
 #define HB_OO_MSG_VIRTUAL       4
 #define HB_OO_MSG_SUPER         5
 #define HB_OO_MSG_ONERROR       6
+#define HB_OO_MSG_CLSMTHD       7 //for the futur ;-) RAC&JF
 
 /* Data */
 #define HB_OO_DATA_SYMBOL       1
 #define HB_OO_DATA_VALUE        2
+#define HB_OO_DATA_TYPE         3
+#define HB_OO_DATA_SCOPE        4
 
 /* ClassData */
 #define HB_OO_CLSD_SYMBOL       1
 #define HB_OO_CLSD_VALUE        2
+#define HB_OO_CLSD_TYPE         3
+#define HB_OO_CLSD_SCOPE        4
 
+/* Method */
+#define HB_OO_MTHD_SYMBOL       1
+#define HB_OO_MTHD_PFUNCTION    2
+#define HB_OO_MTHD_SCOPE        3
+
+//Added by RAC&JF
+/* ClassMethod */ //for the future ;-)
+#define HB_OO_CLSM_SYMBOL       1
+#define HB_OO_CLSM_PFUNCTION    2
+#define HB_OO_CLSM_SCOPE        3
 #endif /* HB_OO_CH_ */
 
diff --git a/harbour/include/hbsetup.ch b/harbour/include/hbsetup.ch
index ecb75e0f15..fb31f962c8 100644
--- a/harbour/include/hbsetup.ch
+++ b/harbour/include/hbsetup.ch
@@ -38,7 +38,7 @@
 #ifndef HB_SETUP_CH_
 #define HB_SETUP_CH_
 
-/* NOTE: You can select here, which features you to include of the different 
+/* NOTE: You can select here, which features you to include of the different
          Clipper implementations. */
 
 #define HB_EXTENSION              /* Enable Harbour extensions */
@@ -53,5 +53,8 @@
 /* #define HB_COMPAT_FOXPRO */    /* Enable FoxPro extensions */
 /* #define HB_COMPAT_DBASE */     /* Enable dBase extensions */
 
+//Added by RaC&JfL
+#define HB_CLS_MASKHIDDEN         /* Disallow heritence of hidden variables */
+
 #endif /* HB_SETUP_CH_ */
 
diff --git a/harbour/source/rtl/objfunc.prg b/harbour/source/rtl/objfunc.prg
index 3f9279b0a8..68f296531e 100644
--- a/harbour/source/rtl/objfunc.prg
+++ b/harbour/source/rtl/objfunc.prg
@@ -40,6 +40,9 @@
  * Copyright 1999 Antonio Linares <alinares@fivetech.com>
  *    __objGetMsgList
  *
+ * Copyright 2000 Jf. Lefebvre <jfl@mafact.com> and Ra. Cuylen <rac@mafact.com>
+ *    __objDerivedFrom
+ *
  * See doc/license.txt for licensing terms.
  *
  */
@@ -229,3 +232,25 @@ FUNCTION __objDelData( oObject, cSymbol )
    ENDIF
 
    RETURN oObject
+
+
+//Added by RāC&JfL
+FUNCTION __objDerivedFrom( oObject, xSuper )
+   Local lRetVal, cClassName
+
+   IF !ISOBJECT( oObject )
+      __errRT_BASE( EG_ARG, 3101, NIL, ProcName( 0 ) )
+   ENDIF
+
+   IF ISOBJECT( xSuper )
+      cClassName := xSuper:ClassName()
+   ELSEIF ISCHARACTER( xSuper )
+      cClassName := Upper( xSuper )
+   ELSE
+      __errRT_BASE( EG_ARG, 3101, NIL, ProcName( 0 ) )
+   ENDIF
+
+   lRetVal := __ClsParent( oObject:ClassH, cClassName )
+
+   RETURN lRetVal
+
diff --git a/harbour/source/rtl/tclass.prg b/harbour/source/rtl/tclass.prg
index acd1273228..9f13154659 100644
--- a/harbour/source/rtl/tclass.prg
+++ b/harbour/source/rtl/tclass.prg
@@ -6,6 +6,8 @@
  * Harbour Project source code:
  * Base Class for internal handling of class creation
  *
+ * Copyright 2000 J. Lefebvre <jfl@mafact.com> & RA. Cuylen <rac@mafact.com>
+ *
  * Copyright 1999 Antonio Linares <alinares@fivetech.com>
  * www - http://www.harbour-project.org
  *
@@ -37,6 +39,15 @@
  * The following parts are Copyright of the individual authors.
  * www - http://www.harbour-project.org
  *
+ * Copyright 2000 J. Lefebvre <jfl@mafact.com> & RA. Cuylen <rac@mafact.com>
+ *    Multiple inheritance
+ *    Support shared class DATA
+ *    scoping (hidden, protected, readOnly)
+ *    Use of __cls_param function to allow multiple superclass declaration
+ *    Suppress of SetType and SetInit not more nedded
+ *    Delegation and forwarding
+ *    Reworking of hashing  as dicRealloc
+ *
  * Copyright 1999 Eddie Runia <eddie@runia.com>
  *    Support for inheritance
  *    Support for default DATA values
@@ -54,23 +65,24 @@
 
 FUNCTION TClass()
 
-   STATIC s_hClass
+   STATIC s_hClass := NIL
 
    IF s_hClass == NIL
-      s_hClass := __clsNew( "TCLASS", 11 )
+      s_hClass := __clsNew( "TCLASS", 10 )
 
       __clsAddMsg( s_hClass, "New"         , @New()         , HB_OO_MSG_METHOD )
       __clsAddMsg( s_hClass, "Create"      , @Create()      , HB_OO_MSG_METHOD )
       __clsAddMsg( s_hClass, "AddData"     , @AddData()     , HB_OO_MSG_METHOD )
+      __clsAddMsg( s_hClass, "AddMultiData", @AddMultiData(), HB_OO_MSG_METHOD )
       __clsAddMsg( s_hClass, "AddClassData", @AddClassData(), HB_OO_MSG_METHOD )
+      __clsAddMsg( s_hClass, "AddMultiClsData", @AddMultiClsData(), HB_OO_MSG_METHOD )
       __clsAddMsg( s_hClass, "AddInline"   , @AddInline()   , HB_OO_MSG_METHOD )
       __clsAddMsg( s_hClass, "AddMethod"   , @AddMethod()   , HB_OO_MSG_METHOD )
       __clsAddMsg( s_hClass, "AddVirtual"  , @AddVirtual()  , HB_OO_MSG_METHOD )
       __clsAddMsg( s_hClass, "Instance"    , @Instance()    , HB_OO_MSG_METHOD )
-      __clsAddMsg( s_hClass, "SetInit"     , @SetInit()     , HB_OO_MSG_METHOD )
       __clsAddMsg( s_hClass, "SetOnError"  , @SetOnError()  , HB_OO_MSG_METHOD )
-      __clsAddMsg( s_hClass, "SetType"     , @SetType()     , HB_OO_MSG_METHOD )
-
+      __clsAddMsg( s_hClass, "cSuper"      , {|Self| iif(::acSuper == NIL .OR. len(::acSuper) == 0, NIL, ::acSuper[1] ) }, HB_OO_MSG_INLINE )
+      __clsAddMsg( s_hClass, "_cSuper"     , {|Self, xVal| iif(::acSuper == NIL .OR. len(::acSuper) == 0, (::acSuper := { xVal} ), ::acSuper[1] := xVal), xVal }, HB_OO_MSG_INLINE )
       __clsAddMsg( s_hClass, "hClass"      ,  1, HB_OO_MSG_DATA )
       __clsAddMsg( s_hClass, "_hClass"     ,  1, HB_OO_MSG_DATA )
       __clsAddMsg( s_hClass, "cName"       ,  2, HB_OO_MSG_DATA )
@@ -85,23 +97,37 @@ FUNCTION TClass()
       __clsAddMsg( s_hClass, "_aInlines"   ,  6, HB_OO_MSG_DATA )
       __clsAddMsg( s_hClass, "aVirtuals"   ,  7, HB_OO_MSG_DATA )
       __clsAddMsg( s_hClass, "_aVirtuals"  ,  7, HB_OO_MSG_DATA )
-      __clsAddMsg( s_hClass, "cSuper"      ,  8, HB_OO_MSG_DATA )
-      __clsAddMsg( s_hClass, "_cSuper"     ,  8, HB_OO_MSG_DATA )
-      __clsAddMsg( s_hClass, "uInit"       ,  9, HB_OO_MSG_DATA )
-      __clsAddMsg( s_hClass, "_uInit"      ,  9, HB_OO_MSG_DATA )
-      __clsAddMsg( s_hClass, "cType"       , 10, HB_OO_MSG_DATA )
-      __clsAddMsg( s_hClass, "_cType"      , 10, HB_OO_MSG_DATA )
-      __clsAddMsg( s_hClass, "nOnError"    , 11, HB_OO_MSG_DATA )
-      __clsAddMsg( s_hClass, "_nOnError"   , 11, HB_OO_MSG_DATA )
+      __clsAddMsg( s_hClass, "acSuper"     ,  8, HB_OO_MSG_DATA )
+      __clsAddMsg( s_hClass, "_acSuper"    ,  8, HB_OO_MSG_DATA )
+      __clsAddMsg( s_hClass, "nOnError"    ,  9, HB_OO_MSG_DATA )
+      __clsAddMsg( s_hClass, "_nOnError"   ,  9, HB_OO_MSG_DATA )
    ENDIF
 
    RETURN __clsInst( s_hClass )
 
 //----------------------------------------------------------------------------//
 
-STATIC FUNCTION New( cClassName, cSuper )
+STATIC FUNCTION New( cClassName, xSuper )
+// xSuper is used here as the new preprocessor file (HBCLASS.CH) send here
+// always an array (if no superclass, this will be an empty one)
+// In case of direct class creation (without the help of preprocessor) xSuper can be
+// either NIL or contain the name of the superclass.
 
    LOCAL Self := QSelf()
+   LOCAL nSuper, i
+
+   ::acSuper := {}
+   nSuper := 0
+
+   If Valtype( xSuper ) == 'A'
+      If Len( xSuper ) >= 1
+         ::acSuper := xSuper
+         nSuper := Len( xSuper )
+      EndIf
+   ElseIf Valtype( xSuper ) == 'C'
+         ::acSuper := { xSuper }
+         nSuper := 1
+   EndIf
 
    ::cName     := Upper( cClassName )
    ::aDatas    := {}
@@ -109,9 +135,16 @@ STATIC FUNCTION New( cClassName, cSuper )
    ::aClsDatas := {}
    ::aInlines  := {}
    ::aVirtuals := {}
-   IF ISCHARACTER( cSuper )
-      ::cSuper    := cSuper
-   ENDIF
+
+   For i := 1 to nSuper
+       If !ISCHARACTER( ::acSuper[i] )
+          exit
+       EndIf
+   Next
+   If i < nSuper
+      nSuper := i - 1
+      aSize(::acSuper, nSuper)
+   EndIf
 
    RETURN Self
 
@@ -121,56 +154,68 @@ STATIC FUNCTION Create()
 
    LOCAL Self := QSelf()
    LOCAL n
-   LOCAL nLen
-   LOCAL nLenDatas := Len( ::aDatas )
+   LOCAL nLen := Len( ::acSuper )
+   LOCAL nLenDatas := Len( ::aDatas ) //Datas local to the class !!
    LOCAL nDataBegin := 0
    LOCAL nClassBegin := 0
    LOCAL hClass
-   LOCAL hSuper
-   LOCAL ahSuper := {}
+   LOCAL ahSuper := array( nLen )
+   Local aoSuper := array( nLen )
 
-   IF ::cSuper == NIL
+   If nLen == 0
       hClass := __clsNew( ::cName, nLenDatas )
+   Else                                         // Multi inheritance
+      For n := 1 to nLen
+          ahSuper[n] := __clsInstSuper( Upper( ::acSuper[n] ) ) // Super handle available
+          aoSuper[n] := __clsInst( ahSuper[n] )
+      Next
 
-   else                                         // Single inheritance
-      hSuper := __clsInstSuper( Upper( ::cSuper ) )
-      hClass := __clsNew( ::cName, nLenDatas, hSuper )
-                                                // Add class casts
-      __clsAddMsg( hClass, Upper( ::cSuper ), hSuper, HB_OO_MSG_SUPER )
-      __clsAddMsg( hClass, "__SUPER", hSuper, HB_OO_MSG_SUPER )
+      hClass := __clsNew( ::cName, nLenDatas, ahSuper )
 
-      nDataBegin := __cls_CntData( hSuper )          // Get offset for new DATAs
-      nClassBegin := __cls_CntClsData( hSuper )      // Get offset for new ClassData
-   ENDIF
+      __clsAddMsg( hClass, Upper( ::acSuper[1] ), ahSuper[1], HB_OO_MSG_SUPER, aoSuper[1], HBCLSTP_CLASS + 1 )
+      __clsAddMsg( hClass, "SUPER"              , ahSuper[1], HB_OO_MSG_SUPER, aoSuper[1], HBCLSTP_CLASS + 1 )
+      __clsAddMsg( hClass, "__SUPER"            , ahSuper[1], HB_OO_MSG_SUPER, aoSuper[1], HBCLSTP_CLASS + 1 )
+
+      nDataBegin   += __cls_CntData( ahSuper[1] )        // Get offset for new Datas
+      nClassBegin  += __cls_CntClsData( ahSuper[1] )     // Get offset for new ClassData
+
+      For n := 2 to nLen
+          __clsAddMsg( hClass, Upper( ::acSuper[n] ), ahSuper[n], HB_OO_MSG_SUPER, aoSuper[n], HBCLSTP_CLASS + 1 )
+
+          nDataBegin   += __cls_CntData( ahSuper[n] )        // Get offset for new DATAs
+          nClassBegin  += __cls_CntClsData( ahSuper[n] )     // Get offset for new ClassData
+
+      Next
+
+   EndIf
 
    ::hClass := hClass
 
    FOR n := 1 TO nLenDatas
-      __clsAddMsg( hClass, ::aDatas[ n ][ HB_OO_DATA_SYMBOL ], n + nDataBegin, HB_OO_MSG_DATA, ;
-                           ::aDatas[ n ][ HB_OO_DATA_VALUE ] )
-      __clsAddMsg( hClass, "_" + ::aDatas[ n ][ HB_OO_DATA_SYMBOL ], n + nDataBegin,;
-                   HB_OO_MSG_DATA )
+      __clsAddMsg( hClass, ::aDatas[ n ][ HB_OO_DATA_SYMBOL ]       , n + nDataBegin, ;
+                   HB_OO_MSG_DATA, ::aDatas[ n ][ HB_OO_DATA_VALUE ], ::aDatas[ n ][ HB_OO_DATA_SCOPE ] )
+      __clsAddMsg( hClass, "_" + ::aDatas[ n ][ HB_OO_DATA_SYMBOL ] , n + nDataBegin, ;
+                   HB_OO_MSG_DATA,                                  , ::aDatas[ n ][ HB_OO_DATA_SCOPE ] )
    NEXT
 
    nLen := Len( ::aMethods )
    FOR n := 1 TO nLen
-      __clsAddMsg( hClass, ::aMethods[ n ][ 1 ], ::aMethods[ n ][ 2 ], HB_OO_MSG_METHOD )
+      __clsAddMsg( hClass, ::aMethods[ n ][ HB_OO_MTHD_SYMBOL ], ::aMethods[ n ][ HB_OO_MTHD_PFUNCTION ], HB_OO_MSG_METHOD, , ::aMethods[ n ][ HB_OO_MTHD_SCOPE ] )
    NEXT
 
    nLen := Len( ::aClsDatas )
    FOR n := 1 TO nLen
-      __clsAddMsg( hClass, ::aClsDatas[ n ][ HB_OO_CLSD_SYMBOL ], n + nClassBegin,;
-                   HB_OO_MSG_CLASSDATA, ::aClsDatas[ n ][ HB_OO_CLSD_VALUE ] )
-      __clsAddMsg( hClass, "_" + ::aClsDatas[ n ][ HB_OO_CLSD_SYMBOL ],;
-                   n + nClassBegin, HB_OO_MSG_CLASSDATA )
+      __clsAddMsg( hClass, ::aClsDatas[ n ][ HB_OO_CLSD_SYMBOL ]      , n + nClassBegin,;
+                   HB_OO_MSG_CLASSDATA, ::aClsDatas[ n ][ HB_OO_CLSD_VALUE ], ::aClsDatas[ n ][ HB_OO_CLSD_SCOPE ] )
+      __clsAddMsg( hClass, "_" + ::aClsDatas[ n ][ HB_OO_CLSD_SYMBOL ], n + nClassBegin,;
+                   HB_OO_MSG_CLASSDATA,                                     , ::aClsDatas[ n ][ HB_OO_CLSD_SCOPE ] )
    NEXT
 
    nLen := Len( ::aInlines )
    FOR n := 1 TO nLen
-      __clsAddMsg( hClass, ::aInlines[ n ][ 1 ], ::aInlines[ n ][ 2 ],;
-                HB_OO_MSG_INLINE )
+      __clsAddMsg( hClass, ::aInlines[ n ][ HB_OO_MTHD_SYMBOL ], ::aInlines[ n ][ HB_OO_MTHD_PFUNCTION ],;
+                   HB_OO_MSG_INLINE, , ::aInlines[ n ][ HB_OO_MTHD_SCOPE ] )
    NEXT
-//    __clsAddMsg( hClass, Upper( ::cName ), {| self | self }, HB_OO_MSG_INLINE ) // QUESTION: Useful ?
 
    nLen := Len( ::aVirtuals )
    FOR n := 1 TO nLen
@@ -178,7 +223,7 @@ STATIC FUNCTION Create()
    NEXT
 
    if ::nOnError != nil
-      __clsAddMsg( hClass, ::nOnError,, HB_OO_MSG_ONERROR )
+      __clsAddMsg( hClass, ::nOnError, , HB_OO_MSG_ONERROR )
    endif
 
    RETURN NIL
@@ -193,49 +238,93 @@ STATIC FUNCTION Instance()
 
 //----------------------------------------------------------------------------//
 
-STATIC FUNCTION AddData( cData, xInit )  /* xInit is initializer */
+STATIC FUNCTION AddData( cData, xInit, cType, nScope )  /* xInit is initializer */
 
    LOCAL Self := QSelf()
 
-   IF ::uInit != NIL
-      xInit := ::uInit
-   ENDIF
-
-   AAdd( ::aDatas, { cData, xInit } )
+   AAdd( ::aDatas, { cData, xInit, cType, nScope } )
 
    RETURN NIL
 
 //----------------------------------------------------------------------------//
 
-STATIC FUNCTION AddClassData( cData, xInit )
+STATIC FUNCTION AddMultiData( cType, xInit, nScope, aData )
+
+   Local Self := QSelf()
+   Local i
+   Local nParam := Len(aData)
+
+   For i := 1 to nParam
+       If !ISCHARACTER( aData[i] )
+          exit
+       EndIf
+   Next i
+   If i < nParam
+      nParam := i - 1
+      aSize(aData, nParam)
+   Endif
+
+   For i := 1 to nParam
+
+    ::AddData( aData[i], xInit, cType, nScope )
+
+   next i
+
+RETURN NIL
+
+//----------------------------------------------------------------------------//
+
+STATIC FUNCTION AddClassData( cData, xInit, cType, nScope )
 
    LOCAL Self := QSelf()
 
-   IF ::uInit != NIL
-      xInit := ::uInit
-   ENDIF
+   aAdd( ::aClsDatas, { cData, xInit, cType, nScope } )
 
-   aAdd( ::aClsDatas, { cData, xInit } )
+RETURN NIL
+
+//----------------------------------------------------------------------------//
+
+STATIC FUNCTION AddMultiClsData( cType, xInit, nScope, aData )
+
+   Local Self := QSelf()
+   Local i
+   Local nParam := Len(aData)
+
+   For i := 1 to nParam
+       If !ISCHARACTER( aData[i] )
+          exit
+       EndIf
+   Next i
+   If i < nParam
+      nParam := i - 1
+      aSize(aData, nParam)
+   Endif
+
+   For i := 1 to nParam
+
+   ::AddClassData( aData[i], xInit, cType, nScope )
+
+   Next i
 
    RETURN NIL
 
 //----------------------------------------------------------------------------//
 
-STATIC FUNCTION AddInline( cMethod, bCode )
+STATIC FUNCTION AddInline( cMethod, bCode, nScope )
 
    LOCAL Self := QSelf()
 
-   aAdd( ::aInlines, { cMethod, bCode } )
+   aAdd( ::aInlines, { cMethod, bCode, nScope } )
 
    RETURN NIL
 
 //----------------------------------------------------------------------------//
 
-STATIC FUNCTION AddMethod( cMethod, nFuncPtr )
+STATIC FUNCTION AddMethod( cMethod, nFuncPtr, nScope )
 
    LOCAL Self := QSelf()
 
-   aAdd( ::aMethods, { cMethod, nFuncPtr } )
+   aAdd( ::aMethods, { cMethod, nFuncPtr, nScope } )
 
    RETURN NIL
 
@@ -251,16 +340,6 @@ STATIC FUNCTION AddVirtual( cMethod )
 
 //----------------------------------------------------------------------------//
 
-STATIC FUNCTION SetInit( uValue )
-
-   LOCAL Self := QSelf()
-
-   ::uInit := uValue
-
-   RETURN NIL
-
-//----------------------------------------------------------------------------//
-
 STATIC FUNCTION SetOnError( nFuncPtr )
 
    LOCAL Self := QSelf()
@@ -271,18 +350,3 @@ STATIC FUNCTION SetOnError( nFuncPtr )
 
 //----------------------------------------------------------------------------//
 
-STATIC FUNCTION SetType( cType )
-
-   LOCAL Self := QSelf()
-
-   ::cType := cType
-
-   if cType != nil .and. Upper( cType ) == "LOGICAL" .and. ::uInit == nil
-      ::uInit := .f.
-   else
-      ::uInit := nil
-   endif
-
-   RETURN NIL
-
-//----------------------------------------------------------------------------//
diff --git a/harbour/source/vm/classes.c b/harbour/source/vm/classes.c
index ef57711b31..15b592579f 100644
--- a/harbour/source/vm/classes.c
+++ b/harbour/source/vm/classes.c
@@ -61,8 +61,25 @@
  * Copyright 1999 Janica Lubos <janica@fornax.elf.stuba.sk>
  *    hb_clsDictRealloc()
  *
- * See doc/license.txt for licensing terms.
+ * Copyright 2000 JF. Lefebvre <jfl@mafact.com> & RA. Cuylen <rac@mafact.com>
+ *    Now support of shared and not shared class data
+ *    Multiple inheritence fully implemented
+ *    Multiple datas declaration fully supported
+ *    Super msg correctly respond by a super object
+ *    Scoping : working for protected, hidden and readonly
+ *    Define of HB_MASKHIDDEN allow subclass to not inherit of hidden message
+ *    This implie a message not found error in place of protection error hidden
  *
+ *    hb___msgGetShrData()
+ *    hb___msgSetShrData()
+ *    hb___msgClsParent()
+ *    __Cls_Param()
+ *    __Cls_MsgToNum()  // New Hashing method to allow a better use of buckets
+ *    __IsClsParent()
+ *    __Cls_Scope()
+ *    HBFUNC( SENDER )  // Work in progress
+ *
+ * See doc/license.txt for licensing terms.
  */
 
 #include "hbapi.h"
@@ -71,32 +88,40 @@
 #include "hbvm.h"
 #include "hboo.ch"
 
+#include <ctype.h>
+#include <stdio.h> //for debug...
+
 typedef struct
 {
-   PHB_DYNS pMessage;
-   PHB_FUNC pFunction;
-   USHORT   uiData;
-   USHORT   uiScope;
-   PHB_ITEM pInitValue;
-   BYTE     bClsDataInitiated;
+   PHB_DYNS pMessage;          // Method Symbolic name
+   PHB_FUNC pFunction;         // Function 'pointer'
+   USHORT   uiData;            // Item position for data (Harbour like, begin from 1)
+   USHORT   uiDataShared;      // Item position for datashared (C like, begin from 0)
+   USHORT   uiSprClass;        // Originalclass'handel (super or current class'handel if not herited).
+   USHORT   uiScope;           // Scoping value
+   PHB_ITEM pInitValue;        // Item Value and value for data (could be initiated by INIT KeyWord)
+   BYTE     bClsDataInitiated; // There is one value assigned at init time
 } METHOD, * PMETHOD;
 
 typedef struct
 {
-   char *   szName;
-   USHORT   uiDatas;
-   USHORT   uiDataFirst;   /* First uiData from this class */
+   char *   szName;          // Class name
+   USHORT   uiDatas;         // Total Data Counter
+   USHORT   uiDataFirst;     /* First uiData from this class */
    PMETHOD  pMethods;
-   USHORT   uiMethods;
+   USHORT   uiMethods;       // Total Method initialised Counter
    USHORT   uiHashKey;
-   PHB_ITEM pClassDatas;  /* Array for ClassDatas */
-   PHB_ITEM pInlines;     /* Array for inline codeblocks */
-   PHB_FUNC pFunError;    /* error handler for not defined messages */
+   USHORT   uiDatasShared;   // Total shared Class data within Class data
+   PHB_ITEM pClassDatas;     /* Harbour Array for ClassDatas and shared */
+   PHB_ITEM * pSharedDatas;  /* C Array for ClassDatas Shared Item pointer (hb_Alloc of pointer) */ //Added by RAC&JF
+                             /* This is _NOT_ a Harbour array*/
+   PHB_ITEM pInlines;        /* Array for inline codeblocks */
+   PHB_FUNC pFunError;       /* error handler for not defined messages */
 } CLASS, * PCLASS;
 
-#define BASE_METHODS    200
-#define BUCKET          4
-#define HASH_KEY        ( BASE_METHODS / BUCKET )
+#define BASE_METHODS    255 //starting maximum number of message
+#define BUCKET          5
+#define HASH_KEY        ( BASE_METHODS / BUCKET ) //Idealy, here we want a "nombre premier"
 
 static PCLASS   s_pClasses     = NULL;
 static USHORT   s_uiClasses    = 0;
@@ -105,6 +130,7 @@ static PHB_DYNS s_msgClassName = NULL;
 static PHB_DYNS s_msgClassH    = NULL;
 static PHB_DYNS s_msgEval      = NULL;
 static PHB_DYNS s_msgClassSel  = NULL;
+static PHB_DYNS s_msgClsParent = NULL;
 
 /* All functions contained in classes.c */
 
@@ -115,54 +141,80 @@ static void     hb_clsRelease( PCLASS );
        char *   hb_objGetClsName( PHB_ITEM pObject );
        PHB_FUNC hb_objGetMethod( PHB_ITEM, PHB_SYMB );
        ULONG    hb_objHasMsg( PHB_ITEM pObject, char *szString );
+       void     hb_clsScope( PHB_ITEM pObject, PMETHOD pMethod ); //Added by RAC&JF
+       unsigned __Cls_MsgToNum( PHB_DYNS pMsg ); //Added by RAC&JF
+       USHORT   __IsClsParent( PCLASS pClass, char * szParentName ); //Added by RAC&JF
 
 static HARBOUR  hb___msgClsH( void );
 static HARBOUR  hb___msgClsName( void );
 static HARBOUR  hb___msgClsSel( void );
 static HARBOUR  hb___msgSuper( void );
 static HARBOUR  hb___msgEvalInline( void );
+static HARBOUR  hb___msgClsParent( void ); //Added by RaC&JfL
 static HARBOUR  hb___msgEval( void );
 static HARBOUR  hb___msgVirtual( void );
 static HARBOUR  hb___msgGetClsData( void );
 static HARBOUR  hb___msgSetClsData( void );
+static HARBOUR  hb___msgGetShrData( void ); //Added by RAC&JF
+static HARBOUR  hb___msgSetShrData( void ); //Added by RAC&JF
 static HARBOUR  hb___msgGetData( void );
 static HARBOUR  hb___msgSetData( void );
 
 /* ================================================ */
 
-/*
+/* Modified by RaC&JfL
  * hb_clsDictRealloc( PCLASS )
  *
  * Realloc (widen) class
  */
-
 static void hb_clsDictRealloc( PCLASS pClass )
 {
+
    HB_TRACE(HB_TR_DEBUG, ("hb_clsDictRealloc(%p)", pClass));
 
    if( pClass )
    {
       PMETHOD pNewMethods;
-      USHORT uiNewHashKey = pClass->uiHashKey + 20;
-      USHORT uiMask = uiNewHashKey * BUCKET;
-      USHORT ui;
+      USHORT  uiNewHashKey = pClass->uiHashKey;
+      USHORT  ui, uiLimit = pClass->uiHashKey * BUCKET;
+      USHORT  nOccurs = 1;
 
-      pNewMethods = ( PMETHOD ) hb_xgrab( uiNewHashKey * BUCKET * sizeof( METHOD ) );
-      memset( pNewMethods, 0, uiNewHashKey * BUCKET * sizeof( METHOD ) );
-
-      for( ui = 0; ui < ( pClass->uiHashKey * BUCKET ); ui++ )
+      while( nOccurs != 0 )
       {
-         PHB_DYNS pMessage = ( PHB_DYNS ) pClass->pMethods[ ui ].pMessage;
+         uiNewHashKey += HASH_KEY ;
 
-         if( pMessage )
+         pNewMethods = ( PMETHOD ) hb_xgrab( uiNewHashKey * BUCKET * sizeof( METHOD ) );
+         memset( pNewMethods, 0, uiNewHashKey * BUCKET * sizeof( METHOD ) );
+
+         for( ui = 0; ui < uiLimit; ui++ )
          {
-            USHORT uiAt = ( ( ( unsigned ) pMessage ) % uiNewHashKey ) * BUCKET;
+             PHB_DYNS pMessage = ( PHB_DYNS ) pClass->pMethods[ ui ].pMessage;
 
-            while( pNewMethods[ uiAt ].pMessage &&
-               ( pNewMethods[ uiAt ].pMessage != pMessage ) )
-               uiAt = ( uiAt == uiMask ) ? 0 : uiAt + 1;
+             if( pMessage )
+             {
+                USHORT uiBucket;
+                USHORT uiAt = ( __Cls_MsgToNum( pMessage ) % uiNewHashKey ) * BUCKET;
 
-            pNewMethods[ uiAt ] = pClass->pMethods[ ui ];
+                for( uiBucket = 0; uiBucket < BUCKET ; uiBucket++ )
+                {
+                    if( pNewMethods[ uiAt+uiBucket ].pMessage == 0) //this message position is empty
+                    {
+                       memcpy(pNewMethods + ( uiAt+uiBucket ), pClass->pMethods + ui, sizeof( METHOD ) );
+                       break;
+                    }
+                }
+
+                // Not enough go back to the beginning
+                if( uiBucket >= BUCKET && nOccurs++ <= 5)
+                {
+                   hb_xfree( pNewMethods );
+                   break;
+                }
+                else if ( nOccurs <= 5 )
+                   nOccurs = 0;
+                else
+                   hb_errInternal( 9999, "Not able to realloc classmessage! __clsDictRealloc", NULL, NULL );
+             }
          }
       }
 
@@ -172,12 +224,12 @@ static void hb_clsDictRealloc( PCLASS pClass )
    }
 }
 
+
 /*
  * hb_clsRelease( <pClass> )
  *
  * Release a class from memory
  */
-
 static void hb_clsRelease( PCLASS pClass )
 {
    USHORT uiAt;
@@ -185,7 +237,6 @@ static void hb_clsRelease( PCLASS pClass )
    PMETHOD pMeth = pClass->pMethods;
 
    HB_TRACE(HB_TR_DEBUG, ("hb_clsRelease(%p)", pClass));
-
    for( uiAt = 0; uiAt < uiLimit; uiAt++, pMeth++ ) /* Release initializers */
    {
       if( pMeth->pInitValue )
@@ -193,9 +244,14 @@ static void hb_clsRelease( PCLASS pClass )
    }
 
    hb_xfree( pClass->szName );
+
    hb_xfree( pClass->pMethods );
 
+   if( pClass->pSharedDatas ) //Added by RAC&JF
+      hb_xfree( pClass->pSharedDatas ); // At least one shared data exist
+
    hb_itemRelease( pClass->pClassDatas );
+
    hb_itemRelease( pClass->pInlines );
 }
 
@@ -222,7 +278,7 @@ void hb_clsReleaseAll( void )
 
 
 /*
- * <szName> = hb_objGetClsName( pObject )
+ * <szName> = ( pObject )
  *
  * Get the class name of an object
  *
@@ -284,6 +340,7 @@ char * hb_objGetClsName( PHB_ITEM pObject )
    return szClassName;
 }
 
+
 /*
  * <pFunc> = hb_objGetMethod( <pObject>, <pMessage> )
  *
@@ -293,6 +350,7 @@ PHB_FUNC hb_objGetMethod( PHB_ITEM pObject, PHB_SYMB pMessage )
 {
    USHORT uiClass;
    PHB_DYNS pMsg = pMessage->pDynSym;
+   char Tmp[255];
 
    HB_TRACE(HB_TR_DEBUG, ("hb_objGetMethod(%p, %p)", pObject, pMessage));
 
@@ -303,8 +361,8 @@ PHB_FUNC hb_objGetMethod( PHB_ITEM pObject, PHB_SYMB pMessage )
 
    if( uiClass && uiClass <= s_uiClasses )
    {
-      PCLASS pClass  = &s_pClasses[ uiClass - 1 ];
-      USHORT uiAt    = ( ( ( unsigned ) pMsg ) % pClass->uiHashKey ) * BUCKET;
+      PCLASS pClass  = s_pClasses + ( uiClass - 1 );
+      USHORT uiAt    = ( ( __Cls_MsgToNum( pMsg ) ) % pClass->uiHashKey ) * BUCKET;
       USHORT uiMask  = pClass->uiHashKey * BUCKET;
       USHORT uiLimit = uiAt ? ( uiAt - 1 ) : ( uiMask - 1 );
 
@@ -314,7 +372,9 @@ PHB_FUNC hb_objGetMethod( PHB_ITEM pObject, PHB_SYMB pMessage )
       {
          if( pClass->pMethods[ uiAt ].pMessage == pMsg )
          {
+
             s_pMethod = pClass->pMethods + uiAt;
+            hb_clsScope( pObject, s_pMethod ); //Added by RAC&JF
             return s_pMethod->pFunction;
          }
          uiAt++;
@@ -323,12 +383,16 @@ PHB_FUNC hb_objGetMethod( PHB_ITEM pObject, PHB_SYMB pMessage )
       }
    }
 
+   // JfL&RaC say :
+   //bad method, we should always inherit by default from one generic superobject
+   //wich then should know those methods ! TBD
    if( s_msgClassName == NULL )
    {
       s_msgClassName = hb_dynsymGet( "CLASSNAME" );  /* Standard messages        */
       s_msgClassH    = hb_dynsymGet( "CLASSH" );     /* Not present in classdef. */
       s_msgClassSel  = hb_dynsymGet( "CLASSSEL" );
       s_msgEval      = hb_dynsymGet( "EVAL" );
+      s_msgClsParent = hb_dynsymGet( "ISDERIVEDFROM" );
    }
 
    if( pMsg == s_msgClassName )
@@ -343,9 +407,12 @@ PHB_FUNC hb_objGetMethod( PHB_ITEM pObject, PHB_SYMB pMessage )
    else if( pMsg == s_msgEval )
       return hb___msgEval;
 
+   else if( pMsg == s_msgClsParent )
+      return hb___msgClsParent;
+
    if( uiClass && uiClass <= s_uiClasses )
    {
-      PCLASS pClass  = &s_pClasses[ uiClass - 1 ];
+      PCLASS pClass  = s_pClasses + ( uiClass - 1 );
 
       if( pClass->pFunError )
          return pClass->pFunError;
@@ -354,6 +421,7 @@ PHB_FUNC hb_objGetMethod( PHB_ITEM pObject, PHB_SYMB pMessage )
    return NULL;
 }
 
+
 /*
  * <uPtr> = hb_objHasMsg( <pObject>, <szString> )
  *
@@ -377,7 +445,7 @@ ULONG hb_objHasMsg( PHB_ITEM pObject, char *szString )
 /* ================================================ */
 
 /*
- * __clsAddMsg( <hClass>, <cMessage>, <pFunction>, <nType>, [xInit] )
+ * __clsAddMsg( <hClass>, <cMessage>, <pFunction>, <nType>, [xInit], <uiScope> )
  *
  * Add a message to the class.
  *
@@ -390,23 +458,39 @@ ULONG hb_objHasMsg( PHB_ITEM pObject, char *szString )
  *             HB_OO_MSG_SUPER     : Handle of super class
  * <nType>     see HB_OO_MSG_*
  * <xInit>     Optional initializer for DATA
+ * Added by RAC&JF
+ * <uiScope>   HBCLSTP_EXPORTED        1 : default for data and method
+ *             HBCLSTP_PROTECTED       2 : method or data protected
+ *             HBCLSTP_HIDDEN          4 : method or data hidden
+ *             HBCLSTP_CTOR            8 : method constructor
+ *             HBCLSTP_READONLY       16 : data read only
+ *             HBCLSTP_SHARED         32 : (method or) data shared
+ *             HBCLSTP_CLASS          64 : message is the name of a superclass
+ *             HBCLSTP_SUPER         128 : message is herited
  */
 HB_FUNC( __CLSADDMSG )
 {
    USHORT uiClass = hb_parni( 1 );
+   USHORT uiScope = 1 ; // 1 = exported (default) ; Added by RAC&JF
+
+   //Added by RAC&JF
+   if( hb_pcount() == 6 && ISNUM( 6 ) )
+        uiScope = hb_parni( 6 );
 
    if( uiClass && uiClass <= s_uiClasses )
    {
-      PCLASS   pClass   = &s_pClasses[ uiClass - 1 ];
+      PCLASS   pClass   = s_pClasses + ( uiClass - 1 );
       PHB_DYNS pMessage = hb_dynsymGet( hb_parc( 2 ) );
+      PHB_ITEM pSprObj ;
+
       USHORT   wType    = hb_parni( 4 );
-      USHORT   uiAt     = ( ( ( unsigned ) pMessage ) % pClass->uiHashKey ) * BUCKET;
+      USHORT   uiAt     = ( ( __Cls_MsgToNum( pMessage ) ) % pClass->uiHashKey ) * BUCKET;
       USHORT   uiMask   = pClass->uiHashKey * BUCKET;
       PMETHOD  pNewMeth;
 
       if( wType == HB_OO_MSG_INLINE && hb_param( 3, HB_IT_BLOCK ) == NULL )
       {
-         hb_errRT_BASE( EG_ARG, 3000, NULL, "__CLSADDMSG" );
+          hb_errRT_BASE( EG_ARG, 3000, NULL, "__CLSADDMSG" );
       }
 
       if( pClass->uiMethods > ( pClass->uiHashKey * BUCKET * 2/3 ) )
@@ -419,20 +503,25 @@ HB_FUNC( __CLSADDMSG )
          uiAt = ( uiAt == uiMask ) ? 0 : uiAt + 1;
 
       pNewMeth = pClass->pMethods + uiAt;
+
       if( !pNewMeth->pMessage )
       {
          pNewMeth->pMessage = pMessage;
          pClass->uiMethods++;                    /* One more message         */
       }
 
+      pNewMeth->uiSprClass =  uiClass; //Added by RaC&JfL not yet used
+
       switch( wType )
       {
          case HB_OO_MSG_METHOD:
               pNewMeth->pFunction = ( PHB_FUNC ) hb_parnl( 3 );
+              pNewMeth->uiScope = uiScope;
               break;
 
          case HB_OO_MSG_DATA:
               pNewMeth->uiData = ( USHORT ) hb_parnl( 3 );
+              pNewMeth->uiScope = uiScope;
               if( pMessage->pSymbol->szName[ 0 ] == '_' )
                  pNewMeth->pFunction = hb___msgSetData;
               else
@@ -455,27 +544,82 @@ HB_FUNC( __CLSADDMSG )
               break;
 
          case HB_OO_MSG_CLASSDATA:
+
               pNewMeth->uiData = ( USHORT ) hb_parnl( 3 );
+              pNewMeth->uiScope = uiScope;
 
-              if( ( USHORT ) hb_arrayLen( pClass->pClassDatas ) < pNewMeth->uiData )
-                 hb_arraySize( pClass->pClassDatas, pNewMeth->uiData );
+              //Modified by RAC&JF
+              if( ( pNewMeth->uiScope & HBCLSTP_SHARED ) != HBCLSTP_SHARED )
+              {
+                 if( ( USHORT ) hb_arrayLen( pClass->pClassDatas ) < pNewMeth->uiData )
+                 {
+                    hb_arraySize( pClass->pClassDatas, pNewMeth->uiData );
+                 }
 
-              if( pMessage->pSymbol->szName[ 0 ] == '_' )
-                 pNewMeth->pFunction = hb___msgSetClsData;
+                 if( pMessage->pSymbol->szName[ 0 ] == '_' )
+                    pNewMeth->pFunction = hb___msgSetClsData;
+                 else
+                 {
+                    PHB_ITEM pInit = hb_param( 5, HB_IT_ANY );
+
+                    pNewMeth->pFunction = hb___msgGetClsData;
+
+                    if( pInit && ! HB_IS_NIL( pInit ) ) /* Initializer found */
+                    {
+                       if( HB_IS_ARRAY( pInit ) )
+                          pNewMeth->pInitValue = hb_arrayClone( pInit );
+                       else
+                       {
+                          pNewMeth->pInitValue = hb_itemNew( NULL );
+                          hb_itemCopy( pNewMeth->pInitValue, pInit );
+                       }
+                    }
+                 }
+              }
               else
               {
-                 PHB_ITEM pInit = hb_param( 5, HB_IT_ANY );
-
-                 pNewMeth->pFunction = hb___msgGetClsData;
-
-                 if( pInit && ! HB_IS_NIL( pInit ) ) /* Initializer found */
+                 if( ( USHORT ) hb_arrayLen( pClass->pClassDatas ) < pNewMeth->uiData )
                  {
-                    if( HB_IS_ARRAY( pInit ) )
-                       pNewMeth->pInitValue = hb_arrayClone( pInit );
+                    PHB_ITEM pTmpItemPtr;
+
+                    hb_arraySize( pClass->pClassDatas, pNewMeth->uiData );
+
+                    //Get a copy of the item pointer (not the value!)
+                    pTmpItemPtr = hb_arrayGetItemPtr( pClass->pClassDatas, pNewMeth->uiData );
+
+                    pClass->uiDatasShared++;
+
+                    // Alloc or realloc PtrArray
+                    if( pClass->pSharedDatas )
+                       pClass->pSharedDatas = ( PHB_ITEM * ) hb_xrealloc( pClass->pSharedDatas, pClass->uiDatasShared * sizeof( PHB_ITEM ) );
                     else
+                       pClass->pSharedDatas = ( PHB_ITEM * ) hb_xgrab( sizeof( PHB_ITEM ) );
+
+                    // Store the C array offset
+                    pNewMeth->uiDataShared = pClass->uiDatasShared - 1;
+
+                    // Now store the Ptr itself
+                    pClass->pSharedDatas[ pNewMeth->uiDataShared ] = ( PHB_ITEM ) pTmpItemPtr ;
+
+                 }
+
+                 if( pMessage->pSymbol->szName[ 0 ] == '_' )
+                    pNewMeth->pFunction = hb___msgSetShrData;
+                 else
+                 {
+                    PHB_ITEM pInit = hb_param( 5, HB_IT_ANY );
+
+                    pNewMeth->pFunction = hb___msgGetShrData;
+
+                    if( pInit && ! HB_IS_NIL( pInit ) ) /* Initializer found */
                     {
-                       pNewMeth->pInitValue = hb_itemNew( NULL );
-                       hb_itemCopy( pNewMeth->pInitValue, pInit );
+                       if( HB_IS_ARRAY( pInit ) )
+                          pNewMeth->pInitValue = hb_arrayClone( pInit );
+                       else
+                       {
+                          pNewMeth->pInitValue = hb_itemNew( NULL );
+                          hb_itemCopy( pNewMeth->pInitValue, pInit );
+                       }
                     }
                  }
               }
@@ -483,6 +627,7 @@ HB_FUNC( __CLSADDMSG )
 
          case HB_OO_MSG_INLINE:
               pNewMeth->uiData = ( USHORT ) ( hb_arrayLen( pClass->pInlines ) + 1 );
+              pNewMeth->uiScope = uiScope;
               hb_arraySize( pClass->pInlines, pNewMeth->uiData );
               hb_arraySet(  pClass->pInlines, pNewMeth->uiData,
                             hb_param( 3, HB_IT_BLOCK ) );
@@ -494,7 +639,11 @@ HB_FUNC( __CLSADDMSG )
               break;
 
          case HB_OO_MSG_SUPER:
+              pSprObj = hb_itemParam( 5 );
+
               pNewMeth->uiData    = ( USHORT ) hb_parnl( 3 );
+              pNewMeth->pInitValue= pSprObj; // store the super object
+              pNewMeth->uiScope   = uiScope;
               pNewMeth->pFunction = hb___msgSuper;
               break;
 
@@ -510,19 +659,27 @@ HB_FUNC( __CLSADDMSG )
 }
 
 
-/*
- * <hClass> := __clsNew( <cClassName>, <nDatas>, [hSuper] )
+/* //Modified by RAC&JF
+ * <hClass> := __clsNew( <cClassName>, <nDatas>, [ahSuper] )
  *
  * Create a new class
  *
  * <cClassName> Name of the class
  * <nDatas>     Number of DATAs in the class
- * <hSuper>     Optional handle of superclass
+ * <ahSuper>    Optional handle(s) of superclass(es)
  */
 HB_FUNC( __CLSNEW )
 {
-   USHORT uiSuper = hb_parni( 3 );          /* Super class present */
-   PCLASS pNewCls;
+   PCLASS  pNewCls;
+   PMETHOD pMeth;
+   USHORT  uiSize;
+
+   //Added by JF&RAC
+   PHB_ITEM pSrc, pDst, pahSuper;
+   USHORT i, uiSuper;
+
+   pahSuper = hb_itemParam( 3 );      /* Replace the initial uiSuper   */
+   uiSuper  = hb_itemSize( pahSuper ); /* Number of Super class present */
 
    if( s_pClasses )
       s_pClasses = ( PCLASS ) hb_xrealloc( s_pClasses,
@@ -532,56 +689,226 @@ HB_FUNC( __CLSNEW )
 
    pNewCls = s_pClasses + s_uiClasses;
    pNewCls->szName = ( char * ) hb_xgrab( hb_parclen( 1 ) + 1 );
+
+   memset(pNewCls->szName,0,hb_parclen( 1 ) + 1);
+
    strcpy( pNewCls->szName, hb_parc( 1 ) );
+   pNewCls->uiDataFirst = 0;
+   pNewCls->uiMethods = 0;
+   pNewCls->uiDatasShared = 0;
 
    if( uiSuper )
    {
-      PCLASS pSprCls = s_pClasses + uiSuper - 1;
-      USHORT uiSize, ui;
-
-      pNewCls->uiDataFirst  = pSprCls->uiDatas;
-      pNewCls->uiDatas      = pSprCls->uiDatas + hb_parni( 2 );
-      pNewCls->uiMethods    = pSprCls->uiMethods;
-
-      /* pNewCls->pClassDatas = hb_arrayClone( pSprCls->pClassDatas ); NO! */
-      pNewCls->pClassDatas = hb_itemNew( NULL );
-      hb_itemCopy( pNewCls->pClassDatas, pSprCls->pClassDatas );
-
-      pNewCls->pInlines    = hb_arrayClone( pSprCls->pInlines );
-
-      pNewCls->uiHashKey    = pSprCls->uiHashKey;
-
-      uiSize = pSprCls->uiHashKey * BUCKET * sizeof( METHOD );
-      pNewCls->pMethods = ( PMETHOD ) hb_xgrab( uiSize );
-      memcpy( pNewCls->pMethods, pSprCls->pMethods, uiSize ); /* Copy all super methods   */
-
-      /* Warning! pInitValue members can not just be copied.
-         A new HB_ITEM must be built */
-      for( ui = 0; ui < ( USHORT ) ( pSprCls->uiHashKey * BUCKET ); ui++ )
+      for( i = 1; i <= uiSuper; i++ )
       {
-         if( pNewCls->pMethods[ ui ].pInitValue )
+         PHB_DYNS pMsg;
+         PHB_ITEM pSuper;
+         PHB_ITEM pClsAnyTmp, pClsNewTmp;
+         USHORT nSuper;
+         USHORT nLen, nLenShrDatas, nLenClsDatas, nLenInlines;
+         USHORT ui, uiAt, uiLimit;
+         PCLASS pSprCls;
+
+         pSuper  =  hb_itemNew( NULL );
+         hb_arrayGet( pahSuper, i , pSuper);
+         nSuper  = hb_itemGetNL( pSuper );
+         pSprCls = s_pClasses + ( nSuper - 1 );
+         uiLimit = pSprCls->uiHashKey * BUCKET;
+
+         hb_itemRelease( pSuper );
+
+         pNewCls->uiDataFirst += pSprCls->uiDatas;
+         pNewCls->uiDatas      = pNewCls->uiDataFirst + hb_parni( 2 );
+
+         if( i == 1 ) // This is the first superclass
          {
-            PHB_ITEM pInitValue = hb_itemNew( NULL );
-            hb_itemCopy( pInitValue, pNewCls->pMethods[ ui ].pInitValue );
-            pNewCls->pMethods[ ui ].pInitValue = pInitValue;
+            pNewCls->uiHashKey = pSprCls->uiHashKey;
+
+            // CLASS DATA Not Shared ( new array, new value )
+            pNewCls->pClassDatas  = hb_arrayClone( pSprCls->pClassDatas );
+
+            pNewCls->pSharedDatas = 0;
+
+            if( pSprCls->pSharedDatas )
+            {
+
+               pNewCls->pSharedDatas = ( PHB_ITEM * ) hb_xgrab( sizeof( PHB_ITEM ) * pSprCls->uiDatasShared );
+               pNewCls->uiDatasShared = pSprCls->uiDatasShared;
+
+               hb_xmemcpy( pNewCls->pSharedDatas, pSprCls->pSharedDatas, sizeof( PHB_ITEM ) * pSprCls->uiDatasShared );
+
+            }
+
+            pNewCls->pInlines = hb_arrayClone( pSprCls->pInlines );
+
+            nLenShrDatas = 0 ; // In fact, this is really previous len
+            nLenClsDatas = 0 ; // so we have to init it to 0 for the first
+            nLenInlines  = 0 ; // SuperClass, they will add an offset to the array pos
+
+         }
+         else
+         {
+            USHORT nLenNew, nLenSpr;
+            PHB_ITEM pTmp;
+            ULONG ulLen;
+            ULONG ulPos;
+
+            // Ok add now the previous len to the offset
+            nLenShrDatas += pNewCls->uiDatasShared;
+            nLenClsDatas += hb_itemSize( pNewCls->pClassDatas ) ;
+            nLenInlines  += hb_itemSize( pNewCls->pInlines     ) ;
+
+            //ClassDatas
+            pClsAnyTmp = hb_arrayClone( pSprCls->pClassDatas );
+            nLen = hb_itemSize( pClsAnyTmp );
+            for( ui = 1; ui <= nLen; ui++ )
+            {
+                PHB_ITEM pTmp = hb_itemNew(NULL);
+                hb_arrayGet( pClsAnyTmp, ui, pTmp );
+                hb_arrayAdd( pNewCls->pClassDatas , pTmp );
+                hb_itemRelease( pTmp );
+            }
+            hb_itemRelease( pClsAnyTmp );
+
+            //SharedDatas
+            if( pSprCls->uiDatasShared )
+               if( pNewCls->pSharedDatas )
+               {
+                  pNewCls->pSharedDatas = ( PHB_ITEM * ) hb_xrealloc( pNewCls->pSharedDatas, pSprCls->uiDatasShared * sizeof( PHB_ITEM ) );
+
+                  hb_xmemcpy(pNewCls->pSharedDatas + pNewCls->uiDatasShared , pSprCls->pSharedDatas ,  pSprCls->uiDatasShared * sizeof( PHB_ITEM ) );
+
+                  pNewCls->uiDatasShared += pSprCls->uiDatasShared;
+
+               }
+               else
+               {
+                  pNewCls->pSharedDatas = ( PHB_ITEM * ) hb_xgrab( sizeof( PHB_ITEM ) * pSprCls->uiDatasShared );
+                  pNewCls->uiDatasShared = pSprCls->uiDatasShared;
+                  hb_xmemcpy( pNewCls->pSharedDatas, pSprCls->pSharedDatas, sizeof( PHB_ITEM ) * pSprCls->uiDatasShared );
+               }
+
+            //Inlines
+            pClsAnyTmp = hb_arrayClone( pSprCls->pInlines );
+            nLen = hb_itemSize( pClsAnyTmp );
+            for( ui = 1; ui <= nLen; ui++ )
+            {
+                PHB_ITEM pTmp = hb_itemNew(NULL);
+                hb_arrayGet( pClsAnyTmp, ui, pTmp );
+                hb_arrayAdd( pNewCls->pInlines , pTmp );
+                hb_itemRelease( pTmp );
+            }
+            hb_itemRelease( pClsAnyTmp );
+         }
+
+         if( ( pNewCls->uiMethods + 1 ) > ( pNewCls->uiHashKey * BUCKET * 2/3 ) )
+            hb_clsDictRealloc( pNewCls );
+
+         if( i == 1 )
+         {
+            uiSize = pNewCls->uiHashKey * BUCKET * sizeof( METHOD );
+            pNewCls->pMethods = ( PMETHOD ) hb_xgrab( uiSize );
+            memset( pNewCls->pMethods, 0, uiSize );
+            pNewCls->pFunError = pSprCls->pFunError;
+         }
+
+         for( ui = 0; ui < uiLimit; ui++ )
+         {
+             USHORT uiBucket;
+
+             pMsg = ( PHB_DYNS ) pSprCls->pMethods[ ui ].pMessage;
+
+             if( pMsg )
+             {
+                uiAt = ( ( __Cls_MsgToNum( pMsg ) ) % pNewCls->uiHashKey ) * BUCKET; //here we are exactly the position for this message in the newcls
+
+                for( uiBucket = 0; uiBucket < BUCKET ; uiBucket++ )
+                {
+                    if( ( pSprCls->pMethods[ ui ].uiScope & HBCLSTP_CLASS ) == HBCLSTP_CLASS )
+                       break;
+
+                    #ifdef HB_MASKHIDDEN // no hidden methods allowed by the inheritence.
+                    if( ( pSprCls->pMethods[ ui ].uiScope & HBCLSTP_HIDDEN ) == HBCLSTP_HIDDEN )
+                       break;
+                    #endif
+
+                    if( pNewCls->pMethods[ uiAt+uiBucket ].pMessage == 0) //this message position is empty
+                    {
+                       // Now, we can increment the msg count
+                       pNewCls->uiMethods++;
+
+                       memcpy(pNewCls->pMethods + ( uiAt+uiBucket ), pSprCls->pMethods + ui, sizeof( METHOD ) );
+
+                       if(
+                           pNewCls->pMethods[ uiAt+uiBucket ].pFunction ==  hb___msgSetClsData
+                           ||
+                           pNewCls->pMethods[ uiAt+uiBucket ].pFunction ==  hb___msgGetClsData
+                         )
+                          pNewCls->pMethods[ uiAt+uiBucket ].uiData += nLenClsDatas;
+
+                       if(
+                           pNewCls->pMethods[ uiAt+uiBucket ].pFunction ==  hb___msgSetShrData
+                           ||
+                           pNewCls->pMethods[ uiAt+uiBucket ].pFunction ==  hb___msgGetShrData
+                         )
+                       {
+                          pNewCls->pMethods[ uiAt+uiBucket ].uiData       += nLenClsDatas; // in all case will never used
+                          pNewCls->pMethods[ uiAt+uiBucket ].uiDataShared += nLenShrDatas;
+                       }
+
+                       if( pNewCls->pMethods[ uiAt+uiBucket ].pFunction ==  hb___msgEvalInline )
+                          pNewCls->pMethods[ uiAt+uiBucket ].uiData += nLenInlines;
+
+
+                       if( ( pSprCls->pMethods[ ui ].uiScope & HBCLSTP_SUPER ) != HBCLSTP_SUPER )
+                          pNewCls->pMethods[ uiAt+uiBucket ].uiScope = pSprCls->pMethods[ uiAt ].uiScope + HBCLSTP_SUPER;
+                       else
+                          pNewCls->pMethods[ uiAt+uiBucket ].uiScope = pSprCls->pMethods[ uiAt ].uiScope;
+
+                       if( pSprCls->pMethods[ ui ].pInitValue )
+                       {
+                        PHB_ITEM pInitValue ;
+
+                        if( HB_IS_ARRAY( pSprCls->pMethods[ ui ].pInitValue ) )
+                          pNewCls->pMethods[ uiAt+uiBucket ].pInitValue = hb_arrayClone( pSprCls->pMethods[ ui ].pInitValue );
+                        else
+                         {
+                          pInitValue = hb_itemNew( NULL );
+
+                          hb_itemCopy( pInitValue, pSprCls->pMethods[ ui ].pInitValue );
+                          pNewCls->pMethods[ uiAt+uiBucket ].pInitValue = pInitValue;
+
+                         }
+                       }
+                       break;
+                    }
+                    else
+                       if( pNewCls->pMethods[ uiAt+uiBucket ].pMessage->pSymbol->szName
+                           ==
+                           pMsg->pSymbol->szName ) break;
+                }
+             }
          }
       }
-      pNewCls->pFunError = pSprCls->pFunError;
    }
    else
    {
       pNewCls->uiDatas     = hb_parni( 2 );
       pNewCls->uiDataFirst = 0;
+
       pNewCls->pMethods    = ( PMETHOD ) hb_xgrab( BASE_METHODS * sizeof( METHOD ) );
-      pNewCls->uiMethods   = 0;
-      pNewCls->uiHashKey   = HASH_KEY;           /* BUCKET = 4 repetitions   */
-
-      pNewCls->pClassDatas = hb_itemArrayNew( 0 );
-      pNewCls->pInlines    = hb_itemArrayNew( 0 );
-      pNewCls->pFunError   = NULL;
-
       memset( pNewCls->pMethods, 0, BASE_METHODS * sizeof( METHOD ) );
+
+      pNewCls->uiMethods   = 0;
+      pNewCls->uiHashKey   = HASH_KEY;
+
+      pNewCls->pClassDatas  = hb_itemArrayNew( 0 );
+      pNewCls->pSharedDatas = 0; //Added by RAC&JF
+      pNewCls->pInlines     = hb_itemArrayNew( 0 );
+      pNewCls->pFunError    = NULL;
+
    }
+   hb_itemRelease( pahSuper );
    hb_retni( ++s_uiClasses );
 }
 
@@ -605,9 +932,9 @@ HB_FUNC( __CLSDELMSG )
 
       if( pMsg )
       {
-         PCLASS   pClass   = s_pClasses + uiClass - 1;
+         PCLASS   pClass   = s_pClasses + ( uiClass - 1 );
          USHORT   uiMask   = pClass->uiHashKey * BUCKET;
-         USHORT   uiAt     = ( ( ( unsigned ) pMsg ) % pClass->uiHashKey ) * BUCKET;
+         USHORT   uiAt     = ( ( __Cls_MsgToNum( pMsg ) ) % pClass->uiHashKey ) * BUCKET;
          USHORT   uiLimit  = uiAt ? ( uiAt - 1 ) : ( uiMask - 1 );
 
          while( ( uiAt != uiLimit ) &&
@@ -618,15 +945,16 @@ HB_FUNC( __CLSDELMSG )
             if( uiAt == uiMask )
                uiAt = 0;
          }
-
          if( uiAt != uiLimit )
          {                                         /* Requested method found   */
             PHB_FUNC pFunc = pClass->pMethods[ uiAt ].pFunction;
 
             if( pFunc == hb___msgEvalInline )      /* INLINE method deleted    */
-               hb_arrayDel( pClass->pInlines, pClass->pMethods[ uiAt ].uiData ); /* Delete INLINE block */
-
-            /* Move messages */
+            {
+               hb_arrayDel( pClass->pInlines, pClass->pMethods[ uiAt ].uiData );
+                                                   /* Delete INLINE block      */
+            }
+                                                /* Move messages            */
             while( pClass->pMethods[ uiAt ].pMessage && uiAt != uiLimit )
             {
                memcpy( pClass->pMethods + uiAt,
@@ -636,9 +964,7 @@ HB_FUNC( __CLSDELMSG )
                if( uiAt == uiMask )
                   uiAt = 0;
             }
-
             memset( pClass->pMethods + uiAt, 0, sizeof( METHOD ) );
-
             pClass->uiMethods--;                    /* Decrease number messages */
          }
       }
@@ -666,11 +992,12 @@ HB_FUNC( __CLSINST )
       hb_stack.Return.item.asArray.value->uiClass   = uiClass;
       hb_stack.Return.item.asArray.value->uiPrevCls = 0;
 
+      //Modified By RAC&JF
       for( uiAt = 0; uiAt < uiLimit; uiAt++, pMeth++ )
       {
-         if( pMeth->pInitValue && ! pMeth->bClsDataInitiated )
+         if( pMeth->pInitValue && !( pMeth->bClsDataInitiated ) )
          {
-            if( pMeth->pFunction != hb___msgGetClsData ) /* is a DATA */
+            if( ( pMeth->pFunction != hb___msgGetClsData ) && ( pMeth->pFunction != hb___msgGetShrData ) ) /* is a DATA */
             {
                if( HB_IS_ARRAY( pMeth->pInitValue ) )
                {
@@ -682,17 +1009,32 @@ HB_FUNC( __CLSINST )
                   hb_itemArrayPut( &hb_stack.Return, pMeth->uiData,
                                    pMeth->pInitValue );
             }
-            else  /* it is a ClassData */
-            {
-               HB_ITEM init;
-               hb_arrayGet( pClass->pClassDatas, pMeth->uiData, &init );
-               if( init.type == HB_IT_NIL )
+            else
+               if( pMeth->pFunction == hb___msgGetClsData ) /* it is a ClassData */
                {
-                  hb_arraySet( pClass->pClassDatas, pMeth->uiData, pMeth->pInitValue );
-                  pMeth->bClsDataInitiated = 1;
+                  HB_ITEM init;
+                  hb_arrayGet( pClass->pClassDatas, pMeth->uiData, &init );
+                  if( init.type == HB_IT_NIL )
+                  {
+                     hb_arraySet( pClass->pClassDatas, pMeth->uiData, pMeth->pInitValue );
+                     pMeth->bClsDataInitiated = 1;
+                  }
+                  hb_itemClear( &init );
                }
-               hb_itemClear( &init );
-            }
+               else
+                  if( pMeth->pFunction == hb___msgGetShrData ) /* it is a ClassData SHARED */
+                  {
+                     HB_ITEM init;
+
+                     hb_itemCopy(  &init , *(pClass->pSharedDatas + pMeth->uiDataShared) ) ;
+
+                     if( init.type == HB_IT_NIL )
+                     {
+                        hb_itemCopy( *(pClass->pSharedDatas + pMeth->uiDataShared) , pMeth->pInitValue );
+                        pMeth->bClsDataInitiated = 1;
+                     }
+                     hb_itemClear( &init );
+                  }
          }
       }
    }
@@ -715,8 +1057,8 @@ HB_FUNC( __CLSMODMSG )
 
       if( pMsg )
       {
-         PCLASS   pClass   = s_pClasses + uiClass - 1;
-         USHORT   uiAt     = ( ( ( unsigned ) pMsg ) % pClass->uiHashKey ) * BUCKET;
+         PCLASS   pClass   = s_pClasses + ( uiClass - 1 );
+         USHORT   uiAt     = ( ( __Cls_MsgToNum( pMsg ) ) % pClass->uiHashKey ) * BUCKET;
          USHORT   uiMask   = pClass->uiHashKey * BUCKET;
          USHORT   uiLimit  = uiAt ? ( uiAt - 1 ) : ( uiMask - 1 );
 
@@ -743,7 +1085,9 @@ HB_FUNC( __CLSMODMSG )
                   hb_arraySet( pClass->pInlines, pClass->pMethods[ uiAt ].uiData, pBlock );
             }
             else if( ( pFunc == hb___msgSetData ) || ( pFunc == hb___msgGetData ) )
-               hb_errRT_BASE( EG_ARG, 3004, "Cannot modify a DATA item", "__CLSMODMSG" ); /* Not allowed for DATA */
+            {                                      /* Not allowed for DATA     */
+               hb_errRT_BASE( EG_ARG, 3004, "Cannot modify a DATA item", "__CLSMODMSG" );
+            }
             else                                   /* Modify METHOD            */
                pClass->pMethods[ uiAt ].pFunction = ( PHB_FUNC ) hb_parnl( 3 );
          }
@@ -825,6 +1169,8 @@ HB_FUNC( __OBJCLONE )
  */
 HB_FUNC( __OBJSENDMSG )
 {
+   USHORT uiAt;
+   PCLASS pClass;
    PHB_ITEM pObject  = hb_param( 1, HB_IT_OBJECT );
    PHB_ITEM pMessage = hb_param( 2, HB_IT_STRING );
 
@@ -894,6 +1240,7 @@ HB_FUNC( __CLSINSTSUPER )
 }
 
 
+
 /*
  * <nSeq> = __cls_CntClsData( <hClass> )
  *
@@ -905,11 +1252,10 @@ HB_FUNC( __CLS_CNTCLSDATA )
 
    if( uiClass )
    {
-      PCLASS pClass = &s_pClasses[ uiClass - 1 ];
+      PCLASS pClass = s_pClasses + ( uiClass - 1 );
       hb_retni( hb_arrayLen( pClass->pClassDatas ) );
    }
-   else
-      hb_retni( 0 );
+   else hb_retni( 0 );
 }
 
 
@@ -922,7 +1268,8 @@ HB_FUNC( __CLS_CNTDATA )
 {
    USHORT uiClass = hb_parni( 1 );
 
-   hb_retni( uiClass != 0 ? s_pClasses[ uiClass - 1 ].uiDatas : 0 );
+   if( uiClass )
+      hb_retni( uiClass != 0 ? s_pClasses[ uiClass - 1 ].uiDatas : 0 );
 }
 
 
@@ -935,7 +1282,8 @@ HB_FUNC( __CLS_DECDATA )
 {
    USHORT uiClass = hb_parni( 1 );
 
-   hb_retni( uiClass != 0 ? s_pClasses[ uiClass - 1 ].uiDatas-- : 0 );
+   if( uiClass )
+      hb_retni( s_pClasses[ uiClass - 1 ].uiDatas-- );
 }
 
 
@@ -948,7 +1296,8 @@ HB_FUNC( __CLS_INCDATA )
 {
    USHORT uiClass = hb_parni( 1 );
 
-   hb_retni( uiClass != 0 ? ++s_pClasses[ uiClass - 1 ].uiDatas : 0 );
+   if( uiClass )
+      hb_retni( uiClass != 0 ? ++s_pClasses[ uiClass - 1 ].uiDatas : 0 );
 }
 
 /* NOTE: Undocumented Clipper function */
@@ -989,7 +1338,7 @@ HB_FUNC( __CLASSSEL )
 
    if( uiClass && uiClass <= s_uiClasses )
    {
-      PCLASS pClass = &s_pClasses[ uiClass - 1 ];
+      PCLASS pClass = s_pClasses + ( uiClass - 1 );
       USHORT uiLimit = pClass->uiHashKey * BUCKET; /* Number of Hash keys      */
       USHORT uiPos = 0;
       USHORT uiAt;
@@ -1009,7 +1358,6 @@ HB_FUNC( __CLASSSEL )
          }
       }
    }
-
    hb_itemReturn( pReturn );
    hb_itemRelease( pReturn );
 }
@@ -1030,6 +1378,47 @@ static HARBOUR hb___msgClsH( void )
 }
 
 
+/* Added by JfL&RaC
+ * <logical> <= <obj>:IsDerivedFrom( xParam )
+ *
+ * Return true if <obj> is derived from xParam.
+ * xParam can be either an obj or a classname
+ */
+static HARBOUR hb___msgClsParent( void )
+{
+   PHB_ITEM pItemRef;
+   PHB_ITEM pItemParam;
+   PCLASS pClass;
+   char * szParentName;
+   USHORT uiClass, lRetVal, i;
+
+   if( HB_IS_BYREF( hb_stack.pBase + 1 ) )            /* Variables by reference   */
+      pItemRef = hb_itemUnRef( hb_stack.pBase + 1 );
+   else
+      pItemRef = hb_stack.pBase + 1;
+
+   uiClass = pItemRef->item.asArray.value->uiClass;
+
+   pClass = s_pClasses + ( uiClass - 1 );
+
+   pItemParam = hb_stack.pBase + 2;
+
+   if( HB_IS_OBJECT( pItemParam ) )
+      szParentName = hb_objGetClsName( pItemParam );
+   else if( HB_IS_STRING( pItemParam ) )
+      szParentName = hb_itemGetC( pItemParam );
+
+   for( i = 0; szParentName[ i ] != '\0'; i++ )
+        szParentName[ i ] = toupper( szParentName[ i ] );
+
+   lRetVal = __IsClsParent( pClass, szParentName );
+
+   hb_itemFreeC( szParentName );
+
+   hb_retl( lRetVal );
+}
+
+
 /*
  * <cClassName> := <obj>:ClassName()
  *
@@ -1069,7 +1458,7 @@ static HARBOUR hb___msgClsSel( void )
 
    if( uiClass && uiClass <= s_uiClasses )
    {
-      PCLASS pClass = &s_pClasses[ uiClass - 1 ];
+      PCLASS pClass = s_pClasses + ( uiClass - 1 );
       USHORT uiLimit = pClass->uiHashKey * BUCKET; /* Number of Hash keys      */
       USHORT uiPos = 0;
       USHORT uiAt;
@@ -1163,6 +1552,22 @@ static HARBOUR hb___msgGetClsData( void )
 }
 
 
+//Added by RAC&JF
+/*
+ * __msgGetShrData()
+ *
+ * Internal function to return a SHAREDDATA
+ */
+static HARBOUR hb___msgGetShrData( void )
+{
+   USHORT uiClass = ( hb_stack.pBase + 1 )->item.asArray.value->uiClass;
+
+   if( uiClass && uiClass <= s_uiClasses )
+      hb_itemCopy( &hb_stack.Return , *(s_pClasses[ uiClass - 1 ].pSharedDatas + s_pMethod->uiDataShared) ) ;
+
+}
+
+
 /*
  * __msgGetData()
  *
@@ -1184,18 +1589,15 @@ static HARBOUR hb___msgGetData( void )
 /*
  * __msgSuper()
  *
- * Internal function to cast to a super method
+ * Internal function to return a superobject
  */
 static HARBOUR hb___msgSuper( void )
 {
-   PHB_ITEM pObject = hb_stack.pBase + 1;
-
-   pObject->item.asArray.value->uiPrevCls = pObject->item.asArray.value->uiClass;
-   pObject->item.asArray.value->uiClass   = s_pMethod->uiData;
-
+   PHB_ITEM pObject = s_pMethod->pInitValue ;
    hb_itemCopy( &hb_stack.Return, pObject );
 }
 
+
 /*
  * __msgSetClsData()
  *
@@ -1214,6 +1616,26 @@ static HARBOUR hb___msgSetClsData( void )
    }
 }
 
+//Added by RAC&JF
+/*
+ * __msgSetShrData()
+ *
+ * Internal function to set a SHAREDDATA
+ */
+static HARBOUR hb___msgSetShrData( void )
+{
+   USHORT uiClass = ( hb_stack.pBase + 1 )->item.asArray.value->uiClass;
+   PHB_ITEM pReturn = hb_stack.pBase + 2;
+
+   if( uiClass && uiClass <= s_uiClasses )
+   {
+
+      hb_itemCopy( *(s_pClasses[ uiClass - 1 ].pSharedDatas + s_pMethod->uiDataShared ), pReturn ) ;
+      hb_itemCopy( &hb_stack.Return, pReturn );
+
+   }
+}
+
 
 /*
  * __msgSetData()
@@ -1253,3 +1675,206 @@ HB_FUNC( __GETMESSAGE )
    hb_retc( pBase->item.asSymbol.value->szName );
 }
 
+
+//Added by RAC&JF
+// Used by the preprocessor to implement Classy compatibility to Harbour
+// Receive an variable number of param and return an array of it.
+// No param will return a NULL array
+HB_FUNC( __CLS_PARAM )
+{
+ PHB_ITEM array, iTmp ;
+ USHORT uiParam = hb_pcount() ;
+ USHORT n ;
+
+ array = hb_itemArrayNew( uiParam );
+
+ for (n = 1; n <= uiParam ; n++)
+  {
+     iTmp = hb_itemParam(n);
+     hb_itemArrayPut( array, n, iTmp );
+     hb_itemRelease(iTmp);
+  }
+
+ hb_itemReturn( array );
+ hb_itemRelease( array );
+
+}
+
+
+//Added by RAC&JF
+void hb_clsScope( PHB_ITEM pObject, PMETHOD pMethod )
+{
+   PHB_ITEM pBase = hb_stack.pBase;
+   LONG    iLevel = 1;
+   USHORT  lRetVal = 0;
+   USHORT uiScope = pMethod->uiScope;
+   PHB_DYNS pMessage = pMethod->pMessage;
+   char * szName; char * szNameBase; char * szNameObject;
+
+   while( ( iLevel-- > 0 ) && pBase != hb_stack.pItems )
+         pBase = hb_stack.pItems + pBase->item.asSymbol.stackbase;
+
+   szNameBase = hb_objGetClsName( pBase + 1 );
+   szNameObject = hb_objGetClsName( pObject );
+
+   if( ( iLevel == -1 ) )
+   {
+      if( ( pBase + 1 )->type == HB_IT_ARRAY )  /* it is a message */
+      {
+         if( ( uiScope & HBCLSTP_PROTECTED ) == HBCLSTP_PROTECTED )
+         {
+            lRetVal = strcmp( szNameBase, szNameObject ) != 0;
+
+            if( lRetVal )
+            {
+               strcpy( szName, szNameObject );
+               strcat( szName, ":" );
+               strcat( szName, pMessage->pSymbol->szName );
+               hb_errRT_BASE( EG_NOMETHOD, 1004, "Scope violation (protected)", szName );
+            }
+         }
+         //if CLS_HIDDEN defined, a call to a hidden msg will result to a msg not found error.
+         #ifndef HB_MASKHIDDEN
+         if( ( uiScope & HBCLSTP_HIDDEN ) == HBCLSTP_HIDDEN )
+         {
+            if( ( uiScope & HBCLSTP_SUPER ) == HBCLSTP_SUPER )
+               lRetVal = 1;
+            else
+               lRetVal = strcmp( szNameBase, szNameObject ) != 0;
+
+            if( lRetVal )
+            {
+               strcpy( szName, szNameObject );
+               strcat( szName, ":" );
+               strcat( szName, pMessage->pSymbol->szName );
+               hb_errRT_BASE( EG_NOMETHOD, 1004, "Scope violation (hidden)", szName );
+            }
+         }
+         #endif
+      }
+      else
+         if( ( uiScope & HBCLSTP_PROTECTED ) == HBCLSTP_PROTECTED )
+         {
+             strcpy( szName, szNameObject );
+             strcat( szName, ":" );
+             strcat( szName, pMessage->pSymbol->szName );
+             hb_errRT_BASE( EG_NOMETHOD, 1004, "Scope violation (protected)", szName );
+         }
+         #ifndef CLS_HIDDEN
+         else if( ( uiScope & HBCLSTP_HIDDEN ) == HBCLSTP_HIDDEN )
+         {
+             strcpy( szName, szNameObject );
+             strcat( szName, ":" );
+             strcat( szName, pMessage->pSymbol->szName );
+             hb_errRT_BASE( EG_NOMETHOD, 1004, "Scope violation (hidden)", szName );
+         }
+         #endif
+
+      if( ( uiScope & HBCLSTP_READONLY ) == HBCLSTP_READONLY )
+      {  printf("\nszMsgBase = %s", pMessage->pSymbol->szName);
+         if(
+             ( pMethod->pFunction == hb___msgSetData    ) ||
+             ( pMethod->pFunction == hb___msgSetClsData ) ||
+             ( pMethod->pFunction == hb___msgSetShrData )
+           )
+            lRetVal = 1;
+
+         if( lRetVal )
+         {
+             strcpy( szName, szNameObject );
+             strcat( szName, ":" );
+             strcat( szName, pMessage->pSymbol->szName );
+             hb_errRT_BASE( EG_NOMETHOD, 1004, "Scope violation (readonly)", szName );
+         }
+      }
+   }
+}
+
+
+//Added by RAC&JF
+unsigned __Cls_MsgToNum( PHB_DYNS pMsg )
+{
+   USHORT i;
+   ULONG nRetVal;
+
+   nRetVal = 0;
+
+   for( i = 0; pMsg->pSymbol->szName[ i ] != '\0'; i++)
+      nRetVal = ( ( nRetVal << 1 ) + pMsg->pSymbol->szName[ i ] );
+
+   return( nRetVal );
+}
+
+
+//Added by RAC&JF
+HB_FUNC( __CLSPARENT )
+{
+   USHORT lRetVal, uiAt, uiLimit;
+   USHORT uiClass = hb_parni( 1 );
+   char * szParentName = hb_parc( 2 );
+   PCLASS pClass  = s_pClasses + ( uiClass - 1 );
+
+   lRetVal = __IsClsParent( pClass, szParentName );
+
+   hb_retl( lRetVal );
+}
+
+
+//Added by RAC&JF
+USHORT __IsClsParent( PCLASS pClass, char * szParentName )
+{
+   USHORT lRetVal, uiAt, uiLimit;
+   PCLASS pSprCls ;
+
+   uiLimit = pClass->uiHashKey * BUCKET;
+   lRetVal = 0;
+
+   for( uiAt = 0; uiAt < uiLimit ; uiAt++)
+       if( ( pClass->pMethods[ uiAt ].uiScope & HBCLSTP_CLASS ) == HBCLSTP_CLASS )
+       {
+          if( strcmp( pClass->pMethods[ uiAt ].pMessage->pSymbol->szName, szParentName ) == 0 )
+          {
+             lRetVal = 1;
+
+          }
+       }
+
+   if( !lRetVal )
+      for( uiAt = 0; uiAt < uiLimit ; uiAt++)
+      {
+          if( ( pClass->pMethods[ uiAt ].uiScope & HBCLSTP_CLASS ) == HBCLSTP_CLASS )
+          {
+               pSprCls = s_pClasses + ( ( pClass->pMethods[ uiAt ].uiData ) - 1 );
+               lRetVal = __IsClsParent( pSprCls, szParentName );
+          }
+          if( lRetVal ) break;
+      }
+
+   return( lRetVal );
+}
+
+//Added by RāC&JfL
+HB_FUNC( SENDER )
+{
+   PHB_ITEM pBase = hb_stack.pBase;
+   PHB_ITEM oReturn ;
+   PHB_ITEM oSender;
+   USHORT  iLevel = 1;
+   char * szNameSender;
+
+   while( ( iLevel-- > 0 ) && pBase != hb_stack.pItems )
+         pBase = hb_stack.pItems + pBase->item.asSymbol.stackbase;
+
+   oSender = pBase + 2;
+   szNameSender = hb_objGetClsName( oSender );
+   printf("\nszNameSender : %s", szNameSender);
+
+   if( ( oSender )->type == HB_IT_ARRAY )
+      hb_itemCopy( oReturn, oSender );
+   else
+      oReturn = hb_itemNew( NULL );
+
+ hb_itemCopy(&hb_stack.Return, oReturn);
+ hb_itemRelease( oReturn );
+}
+
diff --git a/harbour/source/vm/proc.c b/harbour/source/vm/proc.c
index 63deb56767..857103155e 100644
--- a/harbour/source/vm/proc.c
+++ b/harbour/source/vm/proc.c
@@ -46,9 +46,24 @@
 
 #include "hbapi.h"
 
+char * hb_procname( int iLevel, char * szName ); //Added by RAC&JF
+
+//Modified by RAC&JF
 HB_FUNC( PROCNAME )
 {
    int iLevel = hb_parni( 1 ) + 1;  /* we are already inside ProcName() */
+   char sName[255];
+
+   // Added by RAC&JF
+   // Extracted to an internal function to allow us to call it from a c hb_internal
+   hb_procname( iLevel, &sName );
+   hb_retc( ( char *) &sName );
+}
+
+/*
+HB_FUNC( PROCNAME )
+{
+   int iLevel = hb_parni( 1 ) + 1;  // we are already inside ProcName()
    PHB_ITEM pBase = hb_stack.pBase;
 
    while( ( iLevel-- > 0 ) && pBase != hb_stack.pItems )
@@ -56,7 +71,7 @@ HB_FUNC( PROCNAME )
 
    if( ( iLevel == -1 ) )
    {
-      if( ( pBase + 1 )->type == HB_IT_ARRAY )  /* it is a method name */
+      if( ( pBase + 1 )->type == HB_IT_ARRAY )  // it is a method name
       {
          char * szProcName;
 
@@ -74,7 +89,7 @@ HB_FUNC( PROCNAME )
    else
       hb_retc( "" );
 }
-
+*/
 HB_FUNC( PROCLINE )
 {
    int iLevel = hb_parni( 1 ) + 1;  /* we are already inside ProcName() */
@@ -100,3 +115,30 @@ HB_FUNC( PROCFILE )
 }
 
 #endif
+
+
+//Added by RAC&JF  because we need it from classes.c
+char * hb_procname( int iLevel, char * szName )
+{
+   PHB_ITEM pBase = hb_stack.pBase;
+
+   while( ( iLevel-- > 0 ) && pBase != hb_stack.pItems )
+      pBase = hb_stack.pItems + pBase->item.asSymbol.stackbase;
+
+   if( ( iLevel == -1 ) )
+   {
+      if( ( pBase + 1 )->type == HB_IT_ARRAY )  /* it is a method name */
+      {
+         strcpy( szName, hb_objGetClsName( pBase + 1 ) );
+         strcat( szName, ":" );
+         strcat( szName, pBase->item.asSymbol.value->szName );
+      }
+      else
+         strcpy( szName, pBase->item.asSymbol.value->szName );
+   }
+   else
+      strcpy( szName, "" );
+
+   return( szName );
+}
+