The following code fails to compile in Delphi mode but successfully compiles in objfpc mode:

type
  TEnum = (a, b, c);
var
  AValue: TEnum;
  AObject : TObject;
implementation
initialization
  AObject := TObject(AValue);

Could this be supported in the Delphi mode as well?

Thanks,
Sean

Please submit a bug report.

Eh ?
As far as I'm concerned this should not compile in Objfpc mode as well ?

Michael.

Sean McIlwain wrote

initialization AObject := TObject(AValue); Could this be supported in the Delphi mode as well?

Forgot to take your pills today? ;)

Micha

It's a typecast, so then almost anything is allowed, except perhaps if the size doesn't match.

Micha

The latter probably being the problem here, sizes of enumeration types differ in Delphi and FPC mode.

Apart from that I don't see any sense in such type of a typecast.

If I were to store such things in a "generic" list data type I would use a pointer list, not an object list, if alone to avoid the risk of accidentally trying to "Free" such objects.

Vinzent.

Now only if we can go ~15 years back in time and tell that to the original developers of VCL and things like TStrings and their data type ;-) . Unfortunately they take TObject only, and there are a lot of cases when casting other data types to it is needed. I wish it was not the case, but it is the reality :-( .

With best regards,
Boian Mitov

-------------------------------------------------------------------- Mitov Software
http://www.mitov.com
--------------------------------------------------------------------

Hmm, point taken. Well, at least TStrings doesn't seem to add any functionality to further handle such "objects", especially it doesn't try "Free"ing any of them.

Vinzent.

It should compile if sizeof(tenum)=sizeof(tobject) else not? So probably also in Delphi this code depends on $Z ($minenum)

Hello,

This will never compile directly on 64 bit platforms (x64/ppc64) because afaik sizeof(enum) always sizeof(tobject) there. The original poster didn't mention his platform afaik.

Maybe use "AObject := TObject(PtrUInt(AValue));".

Minenumsize is not a solution, since the allowed values are only 1,2 or 4 according to the docs.

Regards,
Thomas

It was not meant as a solution, but as a clarification of the behaviour, and to show that in some cases it can work, depending on $Z.

Schatzl Thomas wrote

This will never compile directly on 64 bit platforms (x64/ppc64) because afaik sizeof(enum) always sizeof(tobject) there. The original poster didn't mention his platform afaik.

Sorry, Sean was out of the office yesterday.

Boian hit it exactly; we're doing this cast to store values in the TStrings Objects[] property. The current platform we're targeting is Linux 32-bit, but we'll probably go to 64-bit at some point too, and it would be nice if the cast continued to work as is.

AFAIK, none of the original Delphi code uses MinEnumSize, so it does work there with 1 and 2 byte enumerations as well.

Craig

1. Why not use dummy class like "class tmyenum(tobject) e: myenumtype; end;"? (extra typing is something like "(objects[i] as tmyenum).e" instead of typecasting, but you can [have to] "Free" it: it's normal object)

2. By the way, compared to Delphi, FPC with common arguments wastes much more memory on large amounts of such objects.

Пётр Косаревский wrote

1. Why not use dummy class like "class tmyenum(tobject) e: myenumtype; end;"? (extra typing is something like "(objects[i] as tmyenum).e" instead of typecasting, but you can [have to] "Free" it: it's normal object)

Why would that be better than a simple typecast? Typecasting to/from an object is a fast and easy way to associate an integer or enum with the strings in a TStrings object. We know when we're doing this, and TStrings never does anything with the object, so the alternatives add runtime and code overhead that simply isn't needed. Even if this was a one off thing I'd question introducing an object for it, but in our case there's literally dozens of spots where we use the technique with many different enumerated types.

Craig

Op Fri, 18 Jul 2008, schreef Craig Peterson:

Because you know it is compatible with a Tobject.

Typecasting to/from an object is a fast and easy way to associate an integer or enum with the strings in a TStrings object.

As you have experienced it might be fast, but not easy, since you are making assumptions on the size of enums, causing portability issues between compilers and also platforms.

We know when we're doing this, and TStrings never does anything with the object, so the alternatives add runtime and code overhead that simply isn't needed.

True.

Even if this was a one off thing I'd question introducing an object for it, but in our case there's literally dozens of spots where we use the technique with many different enumerated types.

It's hacking around library limitations. Library limitations should not be fixed with language changes, but by fixing the libraries.

Daniël

Note that this will break if you turn on class type checking (-CR). In other words, you cannot use class type checking to check/debug programs that use this trick.

Jonas

Hmm, can't you turn that off locally?

Is there {$ObjectCheck OFF} ?

Vincent