Hi all you Pascal programmers!

I'm working on a huge OOP tool. I wonder how
you create a method that returns TRUE if the object
is inherited out of another object, ie. it is associated
to another object.

I would like it to be something like;

function IsAssociation (What : ObjectType) : boolean;

I've been trying lot's of things with VMT access and
VMT links low-low-low-level things. But there must
be a way of doing it!!!

Any suggestions or hints?

Greetings, Johan

I could think of a solution requiring registering each class with its parent
(I guess you know how to do that), but that's quite inconvenient...
If you require registering because of streams or so, this might not be too
much more overhead - but still unhandsome...

        Inherited SomeMethodFromParent;

The object must know the address of the parent method. Therefor, the
parent
must internally be known for Borland Pascal. The question is; how is it
known?
What is the link between the parent VMT and the object's VMT? =

All these VMT things is a bit fuzzy. I've tried the following approach
to
the "find parent" dilemma;

    1. Go to the VMT start address
    2. Walk forward passed the two size fields (negsize and size)
    3. Compare objects VMT method links (pointers) until a NIL pointer
is
       found (must be done since I don't know where the VMT ends).
    4. If at least one link was equal, the objects is associated in some
way.

This is very primitive, since it not works always (at least one virtual
method
must not be overridden by the child obj.), and also allows _any_
association.
It would be better with strict association, ie. TRUE only if objects are
directly
inherited out of each other.

/J

          TParent.SomeMethod;

and I afraid TP7.0 simply finds parent during the compilation time when
meets call of inherited method.

      a --- b
         |
         +-- c - d

If you call IsAssociation in b with d as a parameter, it won't
return TRUE, because objects are nested. But if one extrapolate
your idea slightly one could make a method like;

procedure a.IsAssociation (What : ObjectPointerType) : boolean;
begin
    What := (TypeOf(Self) = TypeOf(What^)) or
            Inherited IsAssociation (What) or
            (What^.IsInitialized and What^.IsAssociation(@Self));
end;

But this I believe will not work either, beacuse it's endless
recursion (how do you know when to stop checking the called object).
Also I am sceptical to the TypeOf operator. Are you really sure
that TypeOf returns TRUE when used with Inherited. Isn't the type of
"self" equal when compared in "IsAssociation" and "Inherited
IsAssociation"? Self should always be of the same type?!

But I don't think it's impossible to do this association thing.
If you compare VMTs and uses a modified IsAssociation, it
could would should work. :-/

In a message that I haven't seen, someone wrote:

VMT/DMT formats are well documented in the Inside Borland Pascal chapter.

--

However, I haven't heard "object" used instead of "type" (resp. "class") -
yet "object type", of course. Under "object" alone I'd understand an instance.
Perhaps, I have the German terminology mixed in a little, but that's what I'm
used to. Anyway, it's just words...

At last, your comment shows me a little bit of reason for this kind of
scoping - up to now I haven't seen any reason behind the limitation to units.

But still, I think you'd agree, the scoping is far from perfect, and much
worse than in C++.

But wait... there's something...
Note: The following (probably) only applies to v7.0!

I was surprised about that nil pointer you mentioned. I didn't know of that.
When I tried it, I found that it isn't there! What you saw was the pointer
to the dynamic VMT (terminology?). Since you probably don't use dynamic
methods (actually, I don't think there's much use to them, except TV's/OWL's
event handling, what they've obviously been designed for), the pointer was
nil in your cases.

However, you can make something out of that. If you require that each class
declares (at least) one dynamic method, you can solve your problem, since each
DMT contains a pointer to its parent's DMT.

If a class doesn't declare a new dynamic method, it will use the same DMT as
its parent. So there's still that requirement, but at least you can check for
"strict association".

As another advantage, you could use this index that the dynamic method must
get as an index for the class, as for storing (like TStreamRec.ObjType in TV).

You could also put some other class data in this pseudo procedure, to address
another problem of BP, namely that of missing class variables (resp.
constants), like:

type TMyClass
  procedure MyClassInfo; virtual $4E;
end;

procedure TMyClass.MyClassInfo; assembler;
asm
  db 'MyClass',0 {Descriptor}
  db True        {Cloneable}
  ...            {other, class specific info}
end;

Just fantasizing... (of course, you'd have to make sure this layout is the
same with all classes...)

Surely, this is far from perfect, but you can't make a bad language (bad, of
course, only in this regard!) good by programming in that language. And
Borland will not make the language better, at least not under the name Pascal.

Followup to another part of this thread:

b) Instead of "Typeof(Self)" you'd have to write "Typeof(<this class>)" with
   the consequence that you have to write the method for each class.
   And in that case, it would be easier IMHO (and probably more
   efficient) to register the classes with their parents...

Frank