Delphi Object and Component Reference

 TVarData type

See also

 

Delphi example

TVarData represents the internal structure of a Variant variable.

Unit
System (Delphi) or SysVari (C++)

Delphi syntax:

type

  TVarArrayBound = packed record

  ElementCount: Integer;
  LowBound: Integer;
end;
TVarArrayBoundArray = array [0..0] of TVarArrayBound;

  PVarArray = ^TVarArray;

TVarArray = packed record
  DimCount: Word;
  Flags: Word;
  ElementSize: Integer;
  LockCount: Integer;
  Data: Pointer;
  Bounds: TVarArrayBoundArray;
end;

  TVarData = packed record
    case Integer of
      0: (VType: TVarType;
          case Integer of
            0: (Reserved1: Word;
                case Integer of
                  0: (Reserved2, Reserved3: Word;
                      case Integer of
                        varSmallInt: (VSmallInt: SmallInt);
                        varInteger:  (VInteger: Integer);
                        varSingle:   (VSingle: Single);
                        varDouble:   (VDouble: Double);
                        varCurrency: (VCurrency: Currency);
                        varDate:     (VDate: TDateTime);
                        varOleStr:   (VOleStr: PWideChar);
                        varDispatch: (VDispatch: Pointer);
                        varError:    (VError: HRESULT);
                        varBoolean:  (VBoolean: WordBool);
                        varUnknown:  (VUnknown: Pointer);
                        varShortInt: (VShortInt: ShortInt);
                        varByte:     (VByte: Byte);
                        varWord:     (VWord: Word);
                        varLongWord: (VLongWord: LongWord);
                        varInt64:    (VInt64: Int64);
                        varString:   (VString: Pointer);
                        varAny:      (VAny: Pointer);
                        varArray:    (VArray: PVarArray);
                        varByRef:    (VPointer: Pointer);
                     );
                  1: (VLongs: array[0..2] of LongInt);
               );
            2: (VWords: array [0..6] of Word);
            3: (VBytes: array [0..13] of Byte);
          );
      1: (RawData: array [0..3] of LongInt);
  end;

C++ syntax:

struct TVarData
{
  union
  {
    uint16_t    VType;    // Delphi-compatible - Variant Type member

    VARTYPE     vt;       // 

 tagVARIANT compatible member (Windows 

only)

  };
  uint16_t Reserved1;
  uint16_t Reserved2;
  uint16_t Reserved3;
  union
  {
    // Delphi-compatible Variant members
    Smallint      VSmallint;    //  iVal
    Integer       VInteger;     //  lVal
    Single        VSingle;      //  fltVal
    Double        VDouble;      //  dblVal
    CurrencyBase  VCurrency;    //  cyVal
    TDateTimeBase VDate;        //  date
    PWideChar     VOleStr;      //  bstrVal
    IDispatch*    VDispatch;    //  pdispVal
    HResult       VError;       //  scode
    WordBool      VBoolean;     //  boolVal
    IUnknown*     VUnknown;     //  punkVal
    Byte          VByte;        //  bVal
    Shortint      VShortint;    //  charVal
    Shortint      VShortInt;    //  charVal
    Pointer       VString;      //  ??????
    PVarArray     VArray;       //  parray
    Pointer       VPointer;     //  byref
    __int64       VInt64;       //  ????
    Word          VWord;
    LongWord      VLongWord;

    // 

 tagVARIANT compatible members (from OAIDL.H)

    // Allowing all types marked as [V] (may appear in a VARIANT to be 

initialized)

    // Windows Only
    LONG          lVal;
    BYTE          bVal;
    SHORT         iVal;
    FLOAT         fltVal;
    DOUBLE        dblVal;
    VARIANT_BOOL  boolVal;
    SCODE         scode;
    CY            cyVal;
    DATE          date;
    BSTR          bstrVal;
    LONG64        llVal;
    IUnknown     *punkVal;
    IDispatch    *pdispVal;
    SAFEARRAY    *parray;
    BYTE         *pbVal;
    SHORT        *piVal;
    LONG         *plVal;
    FLOAT        *pfltVal;
    DOUBLE       *pdblVal;
    VARIANT_BOOL *pboolVal;
    SCODE        *pscode;
    CY           *pcyVal;
    DATE         *pdate;

    BSTR         *pbstrVal;
    IUnknown    **ppunkVal;
    IDispatch   **ppdispVal;
    SAFEARRAY   **pparray;
    VARIANT      *pvarVal;
    PVOID         byref;
    CHAR          cVal;
    USHORT        uiVal;
    ULONG         ulVal;
    INT           intVal;
    UINT          uintVal;
    DECIMAL      *pdecVal;
    CHAR         *pcVal;
    USHORT       *puiVal;
    ULONG        *pulVal;
    INT          *pintVal;
    UINT         *puintVal;
    LONG64       *pllVal;
  };
}

Description
The TVarData type represents the internal structure of a Variant variable. 

The VType field of a TVarData record contains the type code of the variant in the lower twelve bits 
(the bits defined by the varTypeMask constant). In addition, the varArray bit may be set to indicate 
that the Variant is an array, and the varByRef bit may be set to indicate that the Variant contains a 
reference as opposed to a value.

The Reserved1, Reserved2, and Reserved3 fields of a TVarData record are unused.

The contents of the remaining eight bytes of a TVarData record depend on the VType field. If 
neither the varArray nor the varByRef bits are set, the Variant contains a value of the given type. 
This can be a predefined type or a custom Variant type.

If the varArray bit is set, the Variant contains a pointer to a TVarArray structure that defines the 
specifics of the array. The type of each array element is given by the varTypeMask bits in the 
VType field.

If the varByRef bit is set, the Variant contains a reference to a value of the type given by the 
varTypeMask and varArray bits in the VType field.

The internal structure of a Variant is compatible with the Variant type used by COM and the 
Win32 APIs. Note that the varString and varAny type codes are features of CLX and not are 
not supported by COM or the Win32 APIs. Variants containing a varString value should 
never be passed to a non-CLX function. Delphi's Automation support automatically converts 
varString Variants to varOleStr variants before passing them as parameters to external 
functions. Variants containing a varAny value should only be passed to CORBA functions.