Discussion:
Prevent Variants unit from being implicitly included?
(too old to reply)
JJ
2016-11-06 20:51:47 UTC
Permalink
Raw Message
I have this simple code.

program test;
type abc = variant;
begin
end.

If I compile it, the compiler includes the Variants unit, even though the
variant type is declared in the System unit.

The above code doesn't even refer the variant type as a variable, so there
no need for variant variable initialization. There should be no variant
related code to be included in the program at all.

So how to prevent the Variant unit to be included into the program by the
compiler? Is there a compiler directive for this? Or a command line
parameter for DCC32?
Peter Below
2016-11-07 17:45:20 UTC
Permalink
Raw Message
Post by JJ
I have this simple code.
program test;
type abc = variant;
begin
end.
If I compile it, the compiler includes the Variants unit, even though
the variant type is declared in the System unit.
The compiler does nothing of this sort, it is the IDE when you save the
program file (which it does automatically when you ask it to compile
the code).
Post by JJ
The above code doesn't even refer the variant type as a variable, so
there no need for variant variable initialization. There should be no
variant related code to be included in the program at all.
So what? In any real code that actually *uses* your abc type you will
need variant support routines. Your example is completely artifical.

You could try to use OleVariant instead of Variant, if you already have
Windows in the Uses clause anyway.
--
Peter Below
TeamB
JJ
2016-11-08 10:18:25 UTC
Permalink
Raw Message
Post by Peter Below
Post by JJ
I have this simple code.
program test;
type abc = variant;
begin
end.
If I compile it, the compiler includes the Variants unit, even though
the variant type is declared in the System unit.
The compiler does nothing of this sort, it is the IDE when you save the
program file (which it does automatically when you ask it to compile
the code).
Yes it does. I actially tested this using DCC32 command line compiler.
Post by Peter Below
Post by JJ
The above code doesn't even refer the variant type as a variable, so
there no need for variant variable initialization. There should be no
variant related code to be included in the program at all.
So what? In any real code that actually *uses* your abc type you will
need variant support routines. Your example is completely artifical.
You could try to use OleVariant instead of Variant, if you already have
Windows in the Uses clause anyway.
I need to implement my own custom variant routines without including the
Variants unit - for smaller executable file. Variant values won't be
accessed as is. They will be type casted to TVarData and will always be
accessed as TVarData from within the custom variant routines. Only those
routines' function declarations need to have "variant" for a type. e.g.

procedure XVariantSet(var v: variant; b: boolean); overload;
begin
TVarData(v).VType:= varBoolean;
TVarData(v).VBoolean:= b;
end;

procedure XVariantSet(var v: variant; i: integer); overload;
begin
TVarData(v).VType:= varInteger;
TVarData(v).VInteger:= i;
end;

Loading...