Hi,

I don't understand why compilation of the program below failed in fpc and objfpc mode. In tp and delphi mode it works as expected but in fpc and objfpc mode the compiler complains :

  blob.pas(17,3) Error: Constants of objects containing a VMT aren't allowed
  blob.pas(17,3) Fatal: Syntax error, ";" expected but "(" found

Since my object has no virtual methods why a VMT ?

Thanks.

{$mode fpc}
program Blob;
type
  TBlob = object
    private
      fId : LongInt;
    public
      constructor Init;
      function Id: LongInt;
  end;
  PBlob=^TBlob;
const
  NullBlob : TBlob = (fId: 0);
{=== TBlob ===}
constructor TBlob.Init;
begin
  fId:=Random(1024) + 1;
end;
function TBlob.Id;
begin
  Id:=fId;
end;
var
  B : TBlob;
begin
  B:=NullBlob;
  WriteLn('B : ', B.Id);
  B.Init;
  WriteLn('B : ', B.Id);
end.

All TObject descendants have a VMT. The destructor is virtual, BTW.

-Flávio

The compiler always adds a VMT if an object has a constructor or destructor. The reason is that the VMT also contains the instance size, which is used by the constructor helper to allocate the required amount of memory.

Jonas

The above is not a TObject descendant. It's a TP-style object.

Jonas

The compiler always adds a VMT if an object has a constructor or destructor. The reason is that the VMT also contains the instance size, which is used by the constructor helper to allocate the required amount of memory.

Ok but why a different behaviour between [fpc | objfpc] mode and [tp | delphi] mode ?

Yann Bat wrote

> The compiler always adds a VMT if an object has a constructor or destructor. The reason is that the VMT also contains the instance size, which is used by the constructor helper to allocate the required amount of memory. Ok but why a different behaviour between [fpc | objfpc] mode and [tp | delphi] mode ?

It is allowed in Delphi and TP because they allow declaring typed constants of objects. I don't remember why it was disabled in the FPC modes, but that happened a long time ago (before the move from cvs to svn). Maybe someone else does.

Jonas

It is allowed in Delphi and TP because they allow declaring typed constants of objects.

Exactly what I wanted to use. I'll have to use constructors so.

Thank you for your help.

Definitely TP-style objects did not have a VMT unless you declared a virtual method, in TP. And a destructor was only virtual if it was declared virtual. Hence typed constant objects could be possible. Presumably FPC decided compatibility with this feature was not desirable?

FP

I believe the same is the case with FPC and _objects_ (not classes) and FPC is thus compatible here. The text above (mentioning constructors allocating the memory) probably refers to classes. In case of objects, constructor does not need to allocate memory because the object is either declared statically, or it's declared dynamically, but the allocation happens before the constructor is invoked.

Tomas

Semantically, yes. Implementation-wise, no:

# [13] new(o,init);
movl _U_P$PROGRAM_O,%ebx
movl L_VMT_P$PROGRAM_TOBJ$non_lazy_ptr,%edx
movl $0,%eax
call L_P$PROGRAM_TOBJ_$__INIT$$LONGBOOL$stub
movl %eax,_U_P$PROGRAM_O

The first $0 parameter (in %eax) indicates that memory still has to be reserved. P$PROGRAM_TOBJ_$__INIT$$LONGBOOL (= tobj.init) calls fpc_help_constructor, which allocates the memory if necessary (based on the size in the VMT, and the VMT is loaded in %edx in the code above).

Jonas

I made a typo in the comment above (my first quoted statement at the top of the mail is still correct though), it should have read "It is allowed in Delphi and TP because they allow declaring typed constants of objects *that contain a VMT*". As I explained, FPC adds a VMT for any object type that contains a constructor or destructor. This by itself may be another incompatibility with TP/Delphi.

Presumably FPC decided compatibility with this feature was not desirable?

The reason for adding the VMT as soon as there is a constructor or destructor may be for implementation reasons, although it's strange that this is TP-incompatible since this was probably implemented by Pierre or Carl-Eric, and they generally paid a lot of attention to being binary compatible to TP as much as possible.

As mentioned before, I don't know the reason for not allowing typed constants of TP-style objects that have a VMT.