home *** CD-ROM | disk | FTP | other *** search
/ Magazyn Internet 2000 May / MICD_2000_05.iso / CBuilder5 / INSTALL / DATA1.CAB / Program_Built_Files / Include / Vcl / sysvari.h < prev    next >
C/C++ Source or Header  |  2000-02-01  |  130KB  |  3,140 lines
  1. // SYSVARI.H: Pascal Variant & Olevariant classes
  2. //
  3. // $Revision:   1.20.1.1  $
  4. // $Date:   08 Dec 1999 16:10:38  $
  5. //
  6. // Copyright (c) 1997, 1999 Borland International
  7.  
  8. #if !defined(SYSVARI_H)
  9. #define SYSVARI_H
  10.  
  11. #if !defined(SystemHPP)
  12. #error Do not include this file directly.  Include 'system.hpp'.
  13. #endif
  14.  
  15. #if !defined(SYSMAC_H)
  16. #include <sysmac.h>
  17. #endif
  18.  
  19. // The following bring in basic windows types + IUnknown
  20. //
  21. #include <wtypes.h>
  22. #include <unknwn.h>
  23.  
  24. #if !defined(DISPATCH_METHOD)
  25. #define DISPATCH_METHOD         0x1
  26. #endif
  27. #if !defined(DISPATCH_PROPERTYGET)
  28. #define DISPATCH_PROPERTYGET    0x2
  29. #endif
  30. #if !defined(DISPATCH_PROPERTYPUT)
  31. #define DISPATCH_PROPERTYPUT    0x4
  32. #endif
  33. #if !defined(DISPATCH_PROPERTYPUTREF)
  34. #define DISPATCH_PROPERTYPUTREF 0x8
  35. #endif
  36.  
  37. // The following are Automation related structures required by either Variant
  38. // or some other VCL Header. We forward ref. the tagStruct and #define the
  39. // typedef name to the tagStruct.
  40. //
  41. interface IDispatch;
  42. typedef union     tagCY   CURRENCY;
  43. typedef struct    tagSAFEARRAY  SAFEARRAY;
  44. typedef struct    tagVARIANT  VARIANT;
  45. struct    tagSTATSTG;
  46. class     TAutoArgsBase;
  47. template <int count> class  TAutoArgs;
  48. template  <class T> class     TVariantT;
  49. typedef   TVariantT<VARIANT>  TVariant;
  50.  
  51.  
  52. #if !defined(SYSTVAR_H)
  53. #include <systvar.h>
  54. #endif
  55.  
  56. #pragma option push -w-inl -w-lvc
  57.  
  58. namespace System
  59. {
  60.  
  61. // NOTE: Defined in OLEAUTO - Keep in sync.
  62. //
  63. static const short int MaxDispArgs = 0x20; // (BCB-42024)
  64.  
  65.  
  66. // Variant Type Descriptors (from System unit)
  67. //
  68. //  varEmpty      <=> VT_EMPTY
  69. //  varNull       <=> VT_NULL
  70. //  varSmallint   <=> VT_I2
  71. //  varInteger    <=> VT_I3
  72. //  varSingle     <=> VT_R4
  73. //  varDouble     <=> VT_R8
  74. //  varCurrency   <=> VT_CY
  75. //  varDate       <=> VT_DATE
  76. //  varOleStr     <=> VT_BSTR
  77. //  varDispatch   <=> VT_DISPATCH
  78. //  varError      <=> VT_ERROR
  79. //  varBoolean    <=> VT_BOOL
  80. //  varVariant    <=> VT_VARIANT
  81. //  varUnknown    <=> VT_UNKNOWN
  82. //  varByte       <=> VT_UI1
  83. //  varString     <=> ??_??
  84. //  varTypeMask   <=> VT_TYPEMASK
  85. //  varArray      <=> VT_ARRAY
  86. //  varByRef      <=> VT_BYREF
  87. //  varStrArg     <=> VT_CLSID
  88.  
  89.   // Encapsulates error code to be stored in Variant
  90.   //
  91.   class VariantError
  92.   {
  93.   public:
  94.     VariantError(SCODE err = DISP_E_PARAMNOTFOUND) : m_scode(err)
  95.     {}
  96.     operator SCODE () const
  97.     {
  98.        return m_scode;
  99.     }
  100.     VariantError& operator = (SCODE err)
  101.     {
  102.       m_scode = err;
  103.       return *this;
  104.     }
  105.  
  106.   protected:
  107.     SCODE m_scode;
  108.   };
  109.  
  110.   class AutoCmd;
  111.  
  112.   class RTL_DELPHIRETURN Variant: public TVarData
  113.   {
  114.     friend class AutoCmd;
  115.  
  116. // NOTE: Insertion/Extraction operators of VCL classes are only visible
  117. //       if VCL_IOSTREAM is defined.
  118. //
  119. #if defined(VCL_IOSTREAM)
  120.     friend ostream& operator << (ostream& os, const Variant& arg);
  121. #endif
  122.  
  123.   public:
  124.     static Variant __fastcall CreateObject(const String& ProgID);
  125.     static Variant __fastcall GetActiveObject(const String& ProgID);
  126.  
  127.     // Default Ctr
  128.     __fastcall Variant();
  129.  
  130.     // Copy Ctr
  131.     __fastcall Variant(const Variant& src);
  132.  
  133.     // Ctr - From basic C++ types
  134.     __fastcall Variant(const bool src);
  135.  
  136.     __fastcall Variant(const char src);
  137.     __fastcall Variant(const signed char src);
  138.     __fastcall Variant(const unsigned char src);
  139.  
  140.     __fastcall Variant(const short src);
  141.     __fastcall Variant(const unsigned short src);
  142.  
  143.     __fastcall Variant(const int src);
  144.     __fastcall Variant(const unsigned int src);
  145.  
  146.     __fastcall Variant(const long src);
  147.     __fastcall Variant(const unsigned long src);
  148.  
  149.     __fastcall Variant(const float src);
  150.     __fastcall Variant(const double src);
  151.     __fastcall Variant(const long double src);
  152.  
  153.     // Ctr - From OLE structures
  154.     __fastcall Variant(const CURRENCY& src);
  155.     __fastcall Variant(SAFEARRAY& src);
  156.     __fastcall Variant(SAFEARRAY* src);
  157.     __fastcall Variant(const VARIANT& src);
  158.     __fastcall Variant(const TVariant& src);
  159.     __fastcall Variant(VARIANT*   src);
  160.  
  161.     // Ctr - From utility classes
  162.     __fastcall Variant(const AnsiString& src);
  163.     __fastcall Variant(const Currency& src);
  164.     __fastcall Variant(const TDateTime& src);
  165.     __fastcall Variant(const VariantError& src);
  166.     __fastcall Variant(const WideString& src);
  167.  
  168.     // Asciiz pointer
  169.     __fastcall Variant(const char* src);            // Treated as pointer Asciiz string
  170.  
  171.     // Ctr - OLE ptrs
  172.     __fastcall Variant(wchar_t* src);               // BSTR support
  173.     __fastcall Variant(IUnknown* src);
  174.     __fastcall Variant(IDispatch* src);
  175.  
  176.     // Ref-counted Dispatch interface object
  177.     __fastcall Variant(const System::DelphiInterface<IDispatch>& src);
  178.  
  179.     //By ref constructors
  180.     __fastcall Variant(signed char* src);
  181.     __fastcall Variant(unsigned char* src);
  182.  
  183.     __fastcall Variant(short* src);
  184.     __fastcall Variant(unsigned short* src);
  185.  
  186.     __fastcall Variant(int* src);
  187.     __fastcall Variant(unsigned int* src);
  188.  
  189.     __fastcall Variant(long* src);
  190.     __fastcall Variant(unsigned long* src);
  191.  
  192.     __fastcall Variant(float* src);
  193.     __fastcall Variant(double* src);
  194.  
  195.     __fastcall Variant(CURRENCY* src);
  196.     __fastcall Variant(SAFEARRAY** src);
  197.  
  198.     __fastcall Variant(wchar_t** src);              // VT_BSTR|VT_BYREF
  199.  
  200.     // Ref Vcl classes
  201.     __fastcall Variant(Currency* src);
  202.     __fastcall Variant(TDateTime* src);
  203.     __fastcall Variant(Variant* src);
  204.  
  205.     // Constructor for array of variants of type varType
  206.     __fastcall Variant(const int* bounds, const int boundsSize, Word varType);
  207.  
  208.     // Constructor for one dimensional array of type Variant
  209.     __fastcall Variant(const Variant* values, const int valuesSize);
  210.  
  211.     __fastcall ~Variant();
  212.  
  213.     // Assignments
  214.     Variant& __fastcall operator =(const Variant& rhs);
  215.  
  216.     Variant& __fastcall operator =(const bool src);
  217.  
  218.     Variant& __fastcall operator =(const char src);
  219.     Variant& __fastcall operator =(const signed char src);
  220.     Variant& __fastcall operator =(const unsigned char src);
  221.  
  222.     Variant& __fastcall operator =(const short src);
  223.     Variant& __fastcall operator =(const unsigned short src);
  224.  
  225.     Variant& __fastcall operator =(const int src);
  226.     Variant& __fastcall operator =(const unsigned int src);
  227.  
  228.     Variant& __fastcall operator =(const long src);
  229.     Variant& __fastcall operator =(const unsigned long src);
  230.  
  231.     Variant& __fastcall operator =(const float src);
  232.     Variant& __fastcall operator =(const double src);
  233.  
  234.     Variant& __fastcall operator =(const CURRENCY& src);
  235.     Variant& __fastcall operator =(SAFEARRAY* src);
  236.     Variant& __fastcall operator =(SAFEARRAY& src);
  237.     Variant& __fastcall operator =(const VARIANT& rhs);
  238.     Variant& __fastcall operator =(const TVariant& rhs);
  239.     Variant& __fastcall operator =(TVariant* rhs);
  240.     Variant& __fastcall operator =(VARIANT* rhs);
  241.  
  242.     Variant& __fastcall operator =(const AnsiString& src);
  243.     Variant& __fastcall operator =(const Currency& src);
  244.     Variant& __fastcall operator =(const TDateTime& src);
  245.     Variant& __fastcall operator =(const VariantError& src);
  246.     Variant& __fastcall operator =(const WideString& src);
  247.     Variant& __fastcall operator =(const System::DelphiInterface<IDispatch>& src);
  248.  
  249.  
  250.     Variant& __fastcall operator =(wchar_t* src);             // BSTR support
  251.     Variant& __fastcall operator =(IUnknown* src);
  252.     Variant& __fastcall operator =(IDispatch* src);
  253.  
  254.     // By ref Assignment
  255.     Variant& __fastcall operator =(const char* src);          // Treated as pointer Asciiz string
  256.     Variant& __fastcall operator =(signed char* src);
  257.     Variant& __fastcall operator =(unsigned char* src);
  258.  
  259.     Variant& __fastcall operator =(short* src);
  260.     Variant& __fastcall operator =(unsigned short* src);
  261.  
  262.     Variant& __fastcall operator =(int* src);
  263.     Variant& __fastcall operator =(unsigned int* src);
  264.  
  265.     Variant& __fastcall operator =(long* src);
  266.     Variant& __fastcall operator =(unsigned long* src);
  267.  
  268.     Variant& __fastcall operator =(float* src);
  269.     Variant& __fastcall operator =(double* src);
  270.  
  271.     Variant& __fastcall operator =(CURRENCY* src);
  272.     Variant& __fastcall operator =(SAFEARRAY** src);
  273.  
  274.     Variant& __fastcall operator =(wchar_t** src);            // VT_BSTR|VT_BYREF
  275.     Variant& __fastcall operator =(IUnknown** src);
  276.     Variant& __fastcall operator =(IDispatch** src);
  277.  
  278.     Variant& __fastcall operator =(Currency* src);
  279.     Variant& __fastcall operator =(TDateTime* src);
  280.     Variant& __fastcall operator =(Variant* src);
  281.  
  282.     // Exotic operators
  283.     Variant& __fastcall operator +=(const Variant& rhs);
  284.     Variant& __fastcall operator -=(const Variant& rhs);
  285.     Variant& __fastcall operator *=(const Variant& rhs);
  286.     Variant& __fastcall operator /=(const Variant& rhs);
  287.     Variant& __fastcall operator %=(const Variant& rhs);
  288.     Variant& __fastcall operator &=(const Variant& rhs);
  289.     Variant& __fastcall operator |=(const Variant& rhs);
  290.     Variant& __fastcall operator ^=(const Variant& rhs);
  291.     Variant& __fastcall operator <<=(const Variant& rhs);
  292.     Variant& __fastcall operator >>=(const Variant& rhs);
  293.  
  294.     // comparisons (Variant on right)
  295.     bool __fastcall operator ==(const Variant& rhs) const;
  296.     bool __fastcall operator !=(const Variant& rhs) const;
  297.     bool __fastcall operator < (const Variant& rhs) const;
  298.     bool __fastcall operator > (const Variant& rhs) const;
  299.     bool __fastcall operator <=(const Variant& rhs) const;
  300.     bool __fastcall operator >=(const Variant& rhs) const;
  301.  
  302.     // comparisons (int on right)
  303.     bool __fastcall operator ==(int rhs) const
  304.     {return operator ==(Variant(rhs));}
  305.     bool __fastcall operator !=(int rhs) const
  306.     {return operator !=(Variant(rhs));}
  307.     bool __fastcall operator < (int rhs) const
  308.     {return operator < (Variant(rhs));}
  309.     bool __fastcall operator > (int rhs) const
  310.     {return operator > (Variant(rhs));}
  311.     bool __fastcall operator <=(int rhs) const
  312.     {return operator <=(Variant(rhs));}
  313.     bool __fastcall operator >=(int rhs) const
  314.     {return operator >=(Variant(rhs));}
  315.  
  316.     // comparisons (string on right)
  317.     bool __fastcall operator ==(const AnsiString& rhs) const
  318.     { return AnsiString(*this) == rhs;}
  319.  
  320.     // comparisons (double on right)
  321.     bool __fastcall operator ==(double rhs) const
  322.     {return operator ==(Variant(rhs));}
  323.     bool __fastcall operator !=(double rhs) const
  324.     {return operator !=(Variant(rhs));}
  325.     bool __fastcall operator < (double rhs) const
  326.     {return operator <(Variant(rhs));}
  327.     bool __fastcall operator > (double rhs) const
  328.     {return operator >(Variant(rhs));}
  329.     bool __fastcall operator <=(double rhs) const
  330.     {return operator <=(Variant(rhs));}
  331.     bool __fastcall operator >=(double rhs) const
  332.     {return operator >=(Variant(rhs));}
  333.  
  334.     // binary operators (Variant on right)
  335.     Variant __fastcall operator +(const Variant& rhs) const;
  336.     Variant __fastcall operator -(const Variant& rhs) const;
  337.     Variant __fastcall operator *(const Variant& rhs) const;
  338.     Variant __fastcall operator /(const Variant& rhs) const;
  339.     Variant __fastcall operator %(const Variant& rhs) const;
  340.     Variant __fastcall operator &(const Variant& rhs) const;
  341.     Variant __fastcall operator |(const Variant& rhs) const;
  342.     Variant __fastcall operator ^(const Variant& rhs) const;
  343.     Variant __fastcall operator <<(const Variant& rhs) const;
  344.     Variant __fastcall operator >>(const Variant& rhs) const;
  345.  
  346.     // binary operators (AnsiString on right)
  347.     Variant __fastcall operator -(const AnsiString& rhs) const
  348.     {return operator -(Variant(rhs));}
  349.     Variant __fastcall operator *(const AnsiString& rhs) const
  350.     {return operator *(Variant(rhs));}
  351.     Variant __fastcall operator /(const AnsiString& rhs) const
  352.     {return operator /(Variant(rhs));}
  353.     Variant __fastcall operator %(const AnsiString& rhs) const
  354.     {return operator %(Variant(rhs));}
  355.     Variant __fastcall operator &(const AnsiString& rhs) const
  356.     {return operator &(Variant(rhs));}
  357.     Variant __fastcall operator |(const AnsiString& rhs) const
  358.     {return operator |(Variant(rhs));}
  359.     Variant __fastcall operator ^(const AnsiString& rhs) const
  360.     {return operator ^(Variant(rhs));}
  361.     Variant __fastcall operator <<(const AnsiString& rhs) const
  362.     {return operator <<(Variant(rhs));}
  363.     Variant __fastcall operator >>(const AnsiString& rhs) const
  364.     {return operator >>(Variant(rhs));}
  365.  
  366.     // binary operators (int on right)
  367.     Variant __fastcall operator +(int rhs) const
  368.     {return operator +(Variant(rhs));}
  369.     Variant __fastcall operator -(int rhs) const
  370.     {return operator -(Variant(rhs));}
  371.     Variant __fastcall operator *(int rhs) const
  372.     {return operator *(Variant(rhs));}
  373.     Variant __fastcall operator /(int rhs) const
  374.     {return operator /(Variant(rhs));}
  375.     Variant __fastcall operator %(int rhs) const
  376.     {return operator %(Variant(rhs));}
  377.     Variant __fastcall operator &(int rhs) const
  378.     {return operator &(Variant(rhs));}
  379.     Variant __fastcall operator |(int rhs) const
  380.     {return operator |(Variant(rhs));}
  381.     Variant __fastcall operator ^(int rhs) const
  382.     {return operator ^(Variant(rhs));}
  383.     Variant __fastcall operator <<(int rhs) const
  384.     {return operator <<(Variant(rhs));}
  385.     Variant __fastcall operator >>(int rhs) const
  386.     {return operator >>(Variant(rhs));}
  387.  
  388.     // binary operators (double on right)
  389.     Variant __fastcall operator +(double rhs) const
  390.     {return operator +(Variant(rhs));}
  391.     Variant __fastcall operator -(double rhs) const
  392.     {return operator -(Variant(rhs));}
  393.     Variant __fastcall operator *(double rhs) const
  394.     {return operator *(Variant(rhs));}
  395.     Variant __fastcall operator /(double rhs) const
  396.     {return operator /(Variant(rhs));}
  397.     Variant __fastcall operator %(double rhs) const
  398.     {return operator %(Variant(rhs));}
  399.     Variant __fastcall operator &(double rhs) const
  400.     {return operator &(Variant(rhs));}
  401.     Variant __fastcall operator |(double rhs) const
  402.     {return operator |(Variant(rhs));}
  403.     Variant __fastcall operator ^(double rhs) const
  404.     {return operator ^(Variant(rhs));}
  405.     Variant __fastcall operator <<(double rhs) const
  406.     {return operator <<(Variant(rhs));}
  407.     Variant __fastcall operator >>(double rhs) const
  408.     {return operator >>(Variant(rhs));}
  409.  
  410.     // unary operators
  411.     Variant __fastcall operator -() const;
  412.     Variant __fastcall operator !() const;
  413.  
  414.     // Conversion operators
  415.     __fastcall operator bool()            const;
  416.  
  417.     __fastcall operator char()            const;
  418.     __fastcall operator signed char()     const;
  419.     __fastcall operator unsigned char()   const;
  420.  
  421.     __fastcall operator short()           const;
  422.     __fastcall operator unsigned short()  const;
  423.  
  424.     __fastcall operator int()             const;
  425.     __fastcall operator unsigned int()    const;
  426.  
  427.     __fastcall operator long()            const;
  428.     __fastcall operator unsigned long()   const;
  429.  
  430.     __fastcall operator float()           const;
  431.     __fastcall operator double()          const;
  432.  
  433.     __fastcall operator AnsiString()      const;
  434.     __fastcall operator Currency()        const;
  435.     __fastcall operator TDateTime()       const;
  436.     __fastcall operator WideString()      const;
  437.  
  438.     __fastcall operator CURRENCY()        const;
  439.     __fastcall operator VARIANT();
  440.     __fastcall operator TVariant();
  441.  
  442.     __fastcall operator wchar_t*()        const;
  443.     __fastcall operator IDispatch*();
  444.     __fastcall operator IUnknown*();
  445.  
  446.     // by ref conversion operators
  447.     /*__fastcall operator char*();*/  // Dangerous - easily used as string instead of VT_I1|VT_BYREF
  448.     __fastcall operator signed char*();
  449.     __fastcall operator unsigned char*();
  450.  
  451.  
  452.     __fastcall operator short*();
  453.     __fastcall operator unsigned short*();
  454.  
  455.     __fastcall operator int*();
  456.     __fastcall operator unsigned int*();
  457.  
  458.     __fastcall operator long*();
  459.     __fastcall operator unsigned long*();
  460.  
  461.     __fastcall operator float*();
  462.     __fastcall operator double*();
  463.  
  464.     /*__fastcall operator CURRENCY*()       const;*/
  465.     /*__fastcall operator SAFEARRAY**()     const;*/
  466.     __fastcall operator VARIANT*();
  467.     __fastcall operator TVariant*();
  468.  
  469.     __fastcall operator Currency*();
  470.     __fastcall operator TDateTime*();
  471.     __fastcall operator wchar_t**();
  472.  
  473.     // HRESULT methods
  474.     //
  475.     void    __fastcall SetError(const HResult err);
  476.     HResult __fastcall GetError() const;
  477.  
  478.     // Manipulate/Set vt_xxx Type
  479.     //
  480.     void      __fastcall Clear();
  481.     Variant&  __fastcall ChangeType(int VarType);
  482.     Variant   __fastcall AsType(int VarType) const;
  483.     Variant   __fastcall Sanitized() const;
  484.  
  485.     // Query vt_xxx Type
  486.     //
  487.     int   __fastcall Type()     const;
  488.     bool  __fastcall IsNull()   const;
  489.     bool  __fastcall IsEmpty()  const;
  490.  
  491.     // Get Base Variant (when vt==VT_VARIANT)
  492.     //
  493.     Variant* __fastcall GetBaseVariant();
  494.  
  495.     // Array support
  496.     //
  497.     bool    __fastcall IsArray() const;
  498.     Variant __fastcall GetElement(const int i1) const;
  499.     Variant __fastcall GetElement(const int i1, const int i2) const;
  500.     Variant __fastcall GetElement(const int i1, const int i2, const int i3) const;
  501.     Variant __fastcall GetElement(const int i1, const int i2, const int i3, const int i4) const;
  502.     Variant __fastcall GetElement(const int i1, const int i2, const int i3, const int i4, const int i5) const;
  503.     void    __fastcall PutElement(const Variant& data, const int i1);
  504.     void    __fastcall PutElement(const Variant& data, const int i1, const int i2);
  505.     void    __fastcall PutElement(const Variant& data, const int i1, const int i2,const int i3);
  506.     void    __fastcall PutElement(const Variant& data, const int i1, const int i2,const int i3, const int i4);
  507.     void    __fastcall PutElement(const Variant& data, const int i1, const int i2,const int i3, const int i4, const int i5);
  508.  
  509.     int     __fastcall ArrayDimCount() const;
  510.     int     __fastcall ArrayLowBound(const int dim = 1) const;
  511.     int     __fastcall ArrayHighBound(const int dim = 1) const;
  512.     void    __fastcall ArrayRedim(int highBound);
  513.     Pointer __fastcall ArrayLock();
  514.     void    __fastcall ArrayUnlock();
  515.  
  516.     // Automation Goodies
  517.     //
  518.     Variant __fastcall Exec(AutoCmd& cmd, Integer lcid = LOCALE_SYSTEM_DEFAULT) const;
  519.  
  520.     // Helper routines used by template member functions
  521.     //
  522.     void    OleProcedure  (const String& name, TAutoArgsBase* args = 0);
  523.     Variant OleFunction   (const String& name, TAutoArgsBase* args = 0);
  524.     Variant OlePropertyGet(const String& name, TAutoArgsBase* args = 0);
  525.     void    OlePropertySet(const String& name, TAutoArgsBase& args);
  526.  
  527.  
  528.     template <class P1>
  529.     void OleProcedure(const String& name, P1 p1);
  530.  
  531.     template <class P1, class P2>
  532.     void OleProcedure(const String& name, P1 p1, P2 p2);
  533.  
  534.     template <class P1, class P2, class P3>
  535.     void OleProcedure(const String& name, P1 p1, P2 p2, P3 p3);
  536.  
  537.     template <class P1, class P2, class P3, class P4>
  538.     void OleProcedure(const String& name, P1 p1, P2 p2, P3 p3, P4 p4);
  539.  
  540.     template <class P1, class P2, class P3, class P4, class P5>
  541.     void OleProcedure(const String& name, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5);
  542.  
  543.     template <class P1, class P2, class P3, class P4, class P5,
  544.               class P6>
  545.     void OleProcedure(const String& name,
  546.       P1 p1, P2 p2, P3 p3, P4 p4, P5 p5,
  547.       P6 p6);
  548.  
  549.     template <class P1, class P2, class P3, class P4, class P5,
  550.               class P6, class P7>
  551.     void OleProcedure(const String& name,
  552.       P1 p1, P2 p2, P3 p3, P4 p4, P5 p5,
  553.       P6 p6, P7 p7);
  554.  
  555.     template <class P1, class P2, class P3, class P4, class P5,
  556.               class P6, class P7, class P8>
  557.     void OleProcedure(const String& name,
  558.       P1 p1, P2 p2, P3 p3, P4 p4, P5 p5,
  559.       P6 p6, P7 p7, P8 p8);
  560.  
  561.     template <class P1, class P2, class P3, class P4, class P5,
  562.               class P6, class P7, class P8, class P9>
  563.     void OleProcedure(const String& name,
  564.       P1 p1, P2 p2, P3 p3, P4 p4, P5 p5,
  565.       P6 p6, P7 p7, P8 p8, P9 p9);
  566.  
  567.     template <class P1, class P2, class P3, class P4, class P5,
  568.               class P6, class P7, class P8, class P9, class P10>
  569.     void OleProcedure(const String& name,
  570.       P1 p1, P2 p2, P3 p3, P4 p4, P5 p5,
  571.       P6 p6, P7 p7, P8 p8, P9 p9, P10 p10);
  572.  
  573.     template <class P1, class P2, class P3, class P4, class P5,
  574.               class P6, class P7, class P8, class P9, class P10,
  575.               class P11>
  576.     void OleProcedure(const String& name,
  577.       P1 p1, P2 p2, P3 p3, P4 p4, P5 p5,
  578.       P6 p6, P7 p7, P8 p8, P9 p9, P10 p10,
  579.       P11 p11);
  580.  
  581.     template <class P1, class P2, class P3, class P4, class P5,
  582.               class P6, class P7, class P8, class P9, class P10,
  583.               class P11, class P12>
  584.     void OleProcedure(const String& name,
  585.       P1 p1, P2 p2, P3 p3, P4 p4, P5 p5,
  586.       P6 p6, P7 p7, P8 p8, P9 p9, P10 p10,
  587.       P11 p11, P12 p12);
  588.  
  589.     template <class P1, class P2, class P3, class P4, class P5,
  590.               class P6, class P7, class P8, class P9, class P10,
  591.               class P11, class P12, class P13>
  592.     void OleProcedure(const String& name,
  593.       P1 p1, P2 p2, P3 p3, P4 p4, P5 p5,
  594.       P6 p6, P7 p7, P8 p8, P9 p9, P10 p10,
  595.       P11 p11, P12 p12, P13 p13);
  596.  
  597.     template <class P1, class P2, class P3, class P4, class P5,
  598.               class P6, class P7, class P8, class P9, class P10,
  599.               class P11, class P12, class P13, class P14>
  600.     void OleProcedure(const String& name,
  601.       P1 p1, P2 p2, P3 p3, P4 p4, P5 p5,
  602.       P6 p6, P7 p7, P8 p8, P9 p9, P10 p10,
  603.       P11 p11, P12 p12, P13 p13, P14 p14);
  604.  
  605.     template <class P1, class P2, class P3, class P4, class P5,
  606.               class P6, class P7, class P8, class P9, class P10,
  607.               class P11, class P12, class P13, class P14, class P15>
  608.     void OleProcedure(const String& name,
  609.       P1 p1, P2 p2, P3 p3, P4 p4, P5 p5,
  610.       P6 p6, P7 p7, P8 p8, P9 p9, P10 p10,
  611.       P11 p11, P12 p12, P13 p13, P14 p14, P15 p15);
  612.  
  613.     template <class P1, class P2, class P3, class P4, class P5,
  614.               class P6, class P7, class P8, class P9, class P10,
  615.               class P11, class P12, class P13, class P14, class P15,
  616.               class P16>
  617.     void OleProcedure(const String& name,
  618.       P1 p1, P2 p2, P3 p3, P4 p4, P5 p5,
  619.       P6 p6, P7 p7, P8 p8, P9 p9, P10 p10,
  620.       P11 p11, P12 p12, P13 p13, P14 p14, P15 p15,
  621.       P16 p16);
  622.  
  623.     template <class P1, class P2, class P3, class P4, class P5,
  624.               class P6, class P7, class P8, class P9, class P10,
  625.               class P11, class P12, class P13, class P14, class P15,
  626.               class P16, class P17>
  627.     void OleProcedure(const String& name,
  628.       P1 p1, P2 p2, P3 p3, P4 p4, P5 p5,
  629.       P6 p6, P7 p7, P8 p8, P9 p9, P10 p10,
  630.       P11 p11, P12 p12, P13 p13, P14 p14, P15 p15,
  631.       P16 p16, P17 p17);
  632.  
  633.     template <class P1, class P2, class P3, class P4, class P5,
  634.               class P6, class P7, class P8, class P9, class P10,
  635.               class P11, class P12, class P13, class P14, class P15,
  636.               class P16, class P17, class P18>
  637.     void OleProcedure(const String& name,
  638.       P1 p1, P2 p2, P3 p3, P4 p4, P5 p5,
  639.       P6 p6, P7 p7, P8 p8, P9 p9, P10 p10,
  640.       P11 p11, P12 p12, P13 p13, P14 p14, P15 p15,
  641.       P16 p16, P17 p17, P18 p18);
  642.  
  643.     template <class P1, class P2, class P3, class P4, class P5,
  644.               class P6, class P7, class P8, class P9, class P10,
  645.               class P11, class P12, class P13, class P14, class P15,
  646.               class P16, class P17, class P18, class P19>
  647.     void OleProcedure(const String& name,
  648.       P1 p1, P2 p2, P3 p3, P4 p4, P5 p5,
  649.       P6 p6, P7 p7, P8 p8, P9 p9, P10 p10,
  650.       P11 p11, P12 p12, P13 p13, P14 p14, P15 p15,
  651.       P16 p16, P17 p17, P18 p18, P19 p19);
  652.  
  653.     template <class P1, class P2, class P3, class P4, class P5,
  654.               class P6, class P7, class P8, class P9, class P10,
  655.               class P11, class P12, class P13, class P14, class P15,
  656.               class P16, class P17, class P18, class P19, class P20>
  657.     void OleProcedure(const String& name,
  658.       P1 p1, P2 p2, P3 p3, P4 p4, P5 p5,
  659.       P6 p6, P7 p7, P8 p8, P9 p9, P10 p10,
  660.       P11 p11, P12 p12, P13 p13, P14 p14, P15 p15,
  661.       P16 p16, P17 p17, P18 p18, P19 p19, P20 p20);
  662.  
  663.     template <class P1, class P2, class P3, class P4, class P5,
  664.               class P6, class P7, class P8, class P9, class P10,
  665.               class P11, class P12, class P13, class P14, class P15,
  666.               class P16, class P17, class P18, class P19, class P20,
  667.               class P21>
  668.     void OleProcedure(const String& name,
  669.       P1 p1, P2 p2, P3 p3, P4 p4, P5 p5,
  670.       P6 p6, P7 p7, P8 p8, P9 p9, P10 p10,
  671.       P11 p11, P12 p12, P13 p13, P14 p14, P15 p15,
  672.       P16 p16, P17 p17, P18 p18, P19 p19, P20 p20,
  673.       P21 p21);
  674.  
  675.     template <class P1, class P2, class P3, class P4, class P5,
  676.               class P6, class P7, class P8, class P9, class P10,
  677.               class P11, class P12, class P13, class P14, class P15,
  678.               class P16, class P17, class P18, class P19, class P20,
  679.               class P21, class P22>
  680.     void OleProcedure(const String& name,
  681.       P1 p1, P2 p2, P3 p3, P4 p4, P5 p5,
  682.       P6 p6, P7 p7, P8 p8, P9 p9, P10 p10,
  683.       P11 p11, P12 p12, P13 p13, P14 p14, P15 p15,
  684.       P16 p16, P17 p17, P18 p18, P19 p19, P20 p20,
  685.       P21 p21, P22 p22);
  686.  
  687.     template <class P1, class P2, class P3, class P4, class P5,
  688.               class P6, class P7, class P8, class P9, class P10,
  689.               class P11, class P12, class P13, class P14, class P15,
  690.               class P16, class P17, class P18, class P19, class P20,
  691.               class P21, class P22, class P23>
  692.     void OleProcedure(const String& name,
  693.       P1 p1, P2 p2, P3 p3, P4 p4, P5 p5,
  694.       P6 p6, P7 p7, P8 p8, P9 p9, P10 p10,
  695.       P11 p11, P12 p12, P13 p13, P14 p14, P15 p15,
  696.       P16 p16, P17 p17, P18 p18, P19 p19, P20 p20,
  697.       P21 p21, P22 p22, P23 p23);
  698.  
  699.     template <class P1, class P2, class P3, class P4, class P5,
  700.               class P6, class P7, class P8, class P9, class P10,
  701.               class P11, class P12, class P13, class P14, class P15,
  702.               class P16, class P17, class P18, class P19, class P20,
  703.               class P21, class P22, class P23, class P24>
  704.     void OleProcedure(const String& name,
  705.       P1 p1, P2 p2, P3 p3, P4 p4, P5 p5,
  706.       P6 p6, P7 p7, P8 p8, P9 p9, P10 p10,
  707.       P11 p11, P12 p12, P13 p13, P14 p14, P15 p15,
  708.       P16 p16, P17 p17, P18 p18, P19 p19, P20 p20,
  709.       P21 p21, P22 p22, P23 p23, P24 p24);
  710.  
  711.     template <class P1, class P2, class P3, class P4, class P5,
  712.               class P6, class P7, class P8, class P9, class P10,
  713.               class P11, class P12, class P13, class P14, class P15,
  714.               class P16, class P17, class P18, class P19, class P20,
  715.               class P21, class P22, class P23, class P24, class P25>
  716.     void OleProcedure(const String& name,
  717.       P1 p1, P2 p2, P3 p3, P4 p4, P5 p5,
  718.       P6 p6, P7 p7, P8 p8, P9 p9, P10 p10,
  719.       P11 p11, P12 p12, P13 p13, P14 p14, P15 p15,
  720.       P16 p16, P17 p17, P18 p18, P19 p19, P20 p20,
  721.       P21 p21, P22 p22, P23 p23, P24 p24, P25 p25);
  722.  
  723.     template <class P1, class P2, class P3, class P4, class P5,
  724.               class P6, class P7, class P8, class P9, class P10,
  725.               class P11, class P12, class P13, class P14, class P15,
  726.               class P16, class P17, class P18, class P19, class P20,
  727.               class P21, class P22, class P23, class P24, class P25,
  728.               class P26>
  729.     void OleProcedure(const String& name,
  730.       P1 p1, P2 p2, P3 p3, P4 p4, P5 p5,
  731.       P6 p6, P7 p7, P8 p8, P9 p9, P10 p10,
  732.       P11 p11, P12 p12, P13 p13, P14 p14, P15 p15,
  733.       P16 p16, P17 p17, P18 p18, P19 p19, P20 p20,
  734.       P21 p21, P22 p22, P23 p23, P24 p24, P25 p25,
  735.       P26 p26);
  736.  
  737.     template <class P1, class P2, class P3, class P4, class P5,
  738.               class P6, class P7, class P8, class P9, class P10,
  739.               class P11, class P12, class P13, class P14, class P15,
  740.               class P16, class P17, class P18, class P19, class P20,
  741.               class P21, class P22, class P23, class P24, class P25,
  742.               class P26, class P27>
  743.     void OleProcedure(const String& name,
  744.       P1 p1, P2 p2, P3 p3, P4 p4, P5 p5,
  745.       P6 p6, P7 p7, P8 p8, P9 p9, P10 p10,
  746.       P11 p11, P12 p12, P13 p13, P14 p14, P15 p15,
  747.       P16 p16, P17 p17, P18 p18, P19 p19, P20 p20,
  748.       P21 p21, P22 p22, P23 p23, P24 p24, P25 p25,
  749.       P26 p26, P27 p27);
  750.  
  751.     template <class P1, class P2, class P3, class P4, class P5,
  752.               class P6, class P7, class P8, class P9, class P10,
  753.               class P11, class P12, class P13, class P14, class P15,
  754.               class P16, class P17, class P18, class P19, class P20,
  755.               class P21, class P22, class P23, class P24, class P25,
  756.               class P26, class P27, class P28>
  757.     void OleProcedure(const String& name,
  758.       P1 p1, P2 p2, P3 p3, P4 p4, P5 p5,
  759.       P6 p6, P7 p7, P8 p8, P9 p9, P10 p10,
  760.       P11 p11, P12 p12, P13 p13, P14 p14, P15 p15,
  761.       P16 p16, P17 p17, P18 p18, P19 p19, P20 p20,
  762.       P21 p21, P22 p22, P23 p23, P24 p24, P25 p25,
  763.       P26 p26, P27 p27, P28 p28);
  764.  
  765.     template <class P1, class P2, class P3, class P4, class P5,
  766.               class P6, class P7, class P8, class P9, class P10,
  767.               class P11, class P12, class P13, class P14, class P15,
  768.               class P16, class P17, class P18, class P19, class P20,
  769.               class P21, class P22, class P23, class P24, class P25,
  770.               class P26, class P27, class P28, class P29>
  771.     void OleProcedure(const String& name,
  772.       P1 p1, P2 p2, P3 p3, P4 p4, P5 p5,
  773.       P6 p6, P7 p7, P8 p8, P9 p9, P10 p10,
  774.       P11 p11, P12 p12, P13 p13, P14 p14, P15 p15,
  775.       P16 p16, P17 p17, P18 p18, P19 p19, P20 p20,
  776.       P21 p21, P22 p22, P23 p23, P24 p24, P25 p25,
  777.       P26 p26, P27 p27, P28 p28, P29 p29);
  778.  
  779.     template <class P1, class P2, class P3, class P4, class P5,
  780.               class P6, class P7, class P8, class P9, class P10,
  781.               class P11, class P12, class P13, class P14, class P15,
  782.               class P16, class P17, class P18, class P19, class P20,
  783.               class P21, class P22, class P23, class P24, class P25,
  784.               class P26, class P27, class P28, class P29, class P30>
  785.     void OleProcedure(const String& name,
  786.       P1 p1, P2 p2, P3 p3, P4 p4, P5 p5,
  787.       P6 p6, P7 p7, P8 p8, P9 p9, P10 p10,
  788.       P11 p11, P12 p12, P13 p13, P14 p14, P15 p15,
  789.       P16 p16, P17 p17, P18 p18, P19 p19, P20 p20,
  790.       P21 p21, P22 p22, P23 p23, P24 p24, P25 p25,
  791.       P26 p26, P27 p27, P28 p28, P29 p29, P30 p30);
  792.  
  793.     template <class P1, class P2, class P3, class P4, class P5,
  794.               class P6, class P7, class P8, class P9, class P10,
  795.               class P11, class P12, class P13, class P14, class P15,
  796.               class P16, class P17, class P18, class P19, class P20,
  797.               class P21, class P22, class P23, class P24, class P25,
  798.               class P26, class P27, class P28, class P29, class P30,
  799.               class P31>
  800.     void OleProcedure(const String& name,
  801.       P1 p1, P2 p2, P3 p3, P4 p4, P5 p5,
  802.       P6 p6, P7 p7, P8 p8, P9 p9, P10 p10,
  803.       P11 p11, P12 p12, P13 p13, P14 p14, P15 p15,
  804.       P16 p16, P17 p17, P18 p18, P19 p19, P20 p20,
  805.       P21 p21, P22 p22, P23 p23, P24 p24, P25 p25,
  806.       P26 p26, P27 p27, P28 p28, P29 p29, P30 p30,
  807.       P31 p31);
  808.  
  809.     template <class P1, class P2, class P3, class P4, class P5,
  810.               class P6, class P7, class P8, class P9, class P10,
  811.               class P11, class P12, class P13, class P14, class P15,
  812.               class P16, class P17, class P18, class P19, class P20,
  813.               class P21, class P22, class P23, class P24, class P25,
  814.               class P26, class P27, class P28, class P29, class P30,
  815.               class P31, class P32>
  816.     void OleProcedure(const String& name,
  817.       P1 p1, P2 p2, P3 p3, P4 p4, P5 p5,
  818.       P6 p6, P7 p7, P8 p8, P9 p9, P10 p10,
  819.       P11 p11, P12 p12, P13 p13, P14 p14, P15 p15,
  820.       P16 p16, P17 p17, P18 p18, P19 p19, P20 p20,
  821.       P21 p21, P22 p22, P23 p23, P24 p24, P25 p25,
  822.       P26 p26, P27 p27, P28 p28, P29 p29, P30 p30,
  823.       P31 p31, P32 p32);
  824.  
  825.     template <class P1>
  826.     Variant OleFunction(const String& name, P1 p1);
  827.  
  828.     template <class P1, class P2>
  829.     Variant OleFunction(const String& name, P1 p1, P2 p2);
  830.  
  831.     template <class P1, class P2, class P3>
  832.     Variant OleFunction(const String& name, P1 p1, P2 p2, P3 p3);
  833.  
  834.     template <class P1, class P2, class P3, class P4>
  835.     Variant OleFunction(const String& name, P1 p1, P2 p2, P3 p3, P4 p4);
  836.  
  837.     template <class P1, class P2, class P3, class P4, class P5>
  838.     Variant OleFunction(const String& name, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5);
  839.  
  840.     template <class P1, class P2, class P3, class P4, class P5,
  841.               class P6>
  842.     Variant OleFunction(const String& name,
  843.       P1 p1, P2 p2, P3 p3, P4 p4, P5 p5,
  844.       P6 p6);
  845.  
  846.     template <class P1, class P2, class P3, class P4, class P5,
  847.               class P6, class P7>
  848.     Variant OleFunction(const String& name,
  849.       P1 p1, P2 p2, P3 p3, P4 p4, P5 p5,
  850.       P6 p6, P7 p7);
  851.  
  852.     template <class P1, class P2, class P3, class P4, class P5,
  853.               class P6, class P7, class P8>
  854.     Variant OleFunction(const String& name,
  855.       P1 p1, P2 p2, P3 p3, P4 p4, P5 p5,
  856.       P6 p6, P7 p7, P8 p8);
  857.  
  858.     template <class P1, class P2, class P3, class P4, class P5,
  859.               class P6, class P7, class P8, class P9>
  860.     Variant OleFunction(const String& name,
  861.       P1 p1, P2 p2, P3 p3, P4 p4, P5 p5,
  862.       P6 p6, P7 p7, P8 p8, P9 p9);
  863.  
  864.     template <class P1, class P2, class P3, class P4, class P5,
  865.               class P6, class P7, class P8, class P9, class P10>
  866.     Variant OleFunction(const String& name,
  867.       P1 p1, P2 p2, P3 p3, P4 p4, P5 p5,
  868.       P6 p6, P7 p7, P8 p8, P9 p9, P10 p10);
  869.  
  870.     template <class P1, class P2, class P3, class P4, class P5,
  871.               class P6, class P7, class P8, class P9, class P10,
  872.               class P11>
  873.     Variant OleFunction(const String& name,
  874.       P1 p1, P2 p2, P3 p3, P4 p4, P5 p5,
  875.       P6 p6, P7 p7, P8 p8, P9 p9, P10 p10,
  876.       P11 p11);
  877.  
  878.     template <class P1, class P2, class P3, class P4, class P5,
  879.               class P6, class P7, class P8, class P9, class P10,
  880.               class P11, class P12>
  881.     Variant OleFunction(const String& name,
  882.       P1 p1, P2 p2, P3 p3, P4 p4, P5 p5,
  883.       P6 p6, P7 p7, P8 p8, P9 p9, P10 p10,
  884.       P11 p11, P12 p12);
  885.  
  886.     template <class P1, class P2, class P3, class P4, class P5,
  887.               class P6, class P7, class P8, class P9, class P10,
  888.               class P11, class P12, class P13>
  889.     Variant OleFunction(const String& name,
  890.       P1 p1, P2 p2, P3 p3, P4 p4, P5 p5,
  891.       P6 p6, P7 p7, P8 p8, P9 p9, P10 p10,
  892.       P11 p11, P12 p12, P13 p13);
  893.  
  894.     template <class P1, class P2, class P3, class P4, class P5,
  895.               class P6, class P7, class P8, class P9, class P10,
  896.               class P11, class P12, class P13, class P14>
  897.     Variant OleFunction(const String& name,
  898.       P1 p1, P2 p2, P3 p3, P4 p4, P5 p5,
  899.       P6 p6, P7 p7, P8 p8, P9 p9, P10 p10,
  900.       P11 p11, P12 p12, P13 p13, P14 p14);
  901.  
  902.     template <class P1, class P2, class P3, class P4, class P5,
  903.               class P6, class P7, class P8, class P9, class P10,
  904.               class P11, class P12, class P13, class P14, class P15>
  905.     Variant OleFunction(const String& name,
  906.       P1 p1, P2 p2, P3 p3, P4 p4, P5 p5,
  907.       P6 p6, P7 p7, P8 p8, P9 p9, P10 p10,
  908.       P11 p11, P12 p12, P13 p13, P14 p14, P15 p15);
  909.  
  910.     template <class P1, class P2, class P3, class P4, class P5,
  911.               class P6, class P7, class P8, class P9, class P10,
  912.               class P11, class P12, class P13, class P14, class P15,
  913.               class P16>
  914.     Variant OleFunction(const String& name,
  915.       P1 p1, P2 p2, P3 p3, P4 p4, P5 p5,
  916.       P6 p6, P7 p7, P8 p8, P9 p9, P10 p10,
  917.       P11 p11, P12 p12, P13 p13, P14 p14, P15 p15,
  918.       P16 p16);
  919.  
  920.     template <class P1, class P2, class P3, class P4, class P5,
  921.               class P6, class P7, class P8, class P9, class P10,
  922.               class P11, class P12, class P13, class P14, class P15,
  923.               class P16, class P17>
  924.     Variant OleFunction(const String& name,
  925.       P1 p1, P2 p2, P3 p3, P4 p4, P5 p5,
  926.       P6 p6, P7 p7, P8 p8, P9 p9, P10 p10,
  927.       P11 p11, P12 p12, P13 p13, P14 p14, P15 p15,
  928.       P16 p16, P17 p17);
  929.  
  930.     template <class P1, class P2, class P3, class P4, class P5,
  931.               class P6, class P7, class P8, class P9, class P10,
  932.               class P11, class P12, class P13, class P14, class P15,
  933.               class P16, class P17, class P18>
  934.     Variant OleFunction(const String& name,
  935.       P1 p1, P2 p2, P3 p3, P4 p4, P5 p5,
  936.       P6 p6, P7 p7, P8 p8, P9 p9, P10 p10,
  937.       P11 p11, P12 p12, P13 p13, P14 p14, P15 p15,
  938.       P16 p16, P17 p17, P18 p18);
  939.  
  940.     template <class P1, class P2, class P3, class P4, class P5,
  941.               class P6, class P7, class P8, class P9, class P10,
  942.               class P11, class P12, class P13, class P14, class P15,
  943.               class P16, class P17, class P18, class P19>
  944.     Variant OleFunction(const String& name,
  945.       P1 p1, P2 p2, P3 p3, P4 p4, P5 p5,
  946.       P6 p6, P7 p7, P8 p8, P9 p9, P10 p10,
  947.       P11 p11, P12 p12, P13 p13, P14 p14, P15 p15,
  948.       P16 p16, P17 p17, P18 p18, P19 p19);
  949.  
  950.     template <class P1, class P2, class P3, class P4, class P5,
  951.               class P6, class P7, class P8, class P9, class P10,
  952.               class P11, class P12, class P13, class P14, class P15,
  953.               class P16, class P17, class P18, class P19, class P20>
  954.     Variant OleFunction(const String& name,
  955.       P1 p1, P2 p2, P3 p3, P4 p4, P5 p5,
  956.       P6 p6, P7 p7, P8 p8, P9 p9, P10 p10,
  957.       P11 p11, P12 p12, P13 p13, P14 p14, P15 p15,
  958.       P16 p16, P17 p17, P18 p18, P19 p19, P20 p20);
  959.  
  960.     template <class P1, class P2, class P3, class P4, class P5,
  961.               class P6, class P7, class P8, class P9, class P10,
  962.               class P11, class P12, class P13, class P14, class P15,
  963.               class P16, class P17, class P18, class P19, class P20,
  964.               class P21>
  965.     Variant OleFunction(const String& name,
  966.       P1 p1, P2 p2, P3 p3, P4 p4, P5 p5,
  967.       P6 p6, P7 p7, P8 p8, P9 p9, P10 p10,
  968.       P11 p11, P12 p12, P13 p13, P14 p14, P15 p15,
  969.       P16 p16, P17 p17, P18 p18, P19 p19, P20 p20,
  970.       P21 p21);
  971.  
  972.     template <class P1, class P2, class P3, class P4, class P5,
  973.               class P6, class P7, class P8, class P9, class P10,
  974.               class P11, class P12, class P13, class P14, class P15,
  975.               class P16, class P17, class P18, class P19, class P20,
  976.               class P21, class P22>
  977.     Variant OleFunction(const String& name,
  978.       P1 p1, P2 p2, P3 p3, P4 p4, P5 p5,
  979.       P6 p6, P7 p7, P8 p8, P9 p9, P10 p10,
  980.       P11 p11, P12 p12, P13 p13, P14 p14, P15 p15,
  981.       P16 p16, P17 p17, P18 p18, P19 p19, P20 p20,
  982.       P21 p21, P22 p22);
  983.  
  984.     template <class P1, class P2, class P3, class P4, class P5,
  985.               class P6, class P7, class P8, class P9, class P10,
  986.               class P11, class P12, class P13, class P14, class P15,
  987.               class P16, class P17, class P18, class P19, class P20,
  988.               class P21, class P22, class P23>
  989.     Variant OleFunction(const String& name,
  990.       P1 p1, P2 p2, P3 p3, P4 p4, P5 p5,
  991.       P6 p6, P7 p7, P8 p8, P9 p9, P10 p10,
  992.       P11 p11, P12 p12, P13 p13, P14 p14, P15 p15,
  993.       P16 p16, P17 p17, P18 p18, P19 p19, P20 p20,
  994.       P21 p21, P22 p22, P23 p23);
  995.  
  996.     template <class P1, class P2, class P3, class P4, class P5,
  997.               class P6, class P7, class P8, class P9, class P10,
  998.               class P11, class P12, class P13, class P14, class P15,
  999.               class P16, class P17, class P18, class P19, class P20,
  1000.               class P21, class P22, class P23, class P24>
  1001.     Variant OleFunction(const String& name,
  1002.       P1 p1, P2 p2, P3 p3, P4 p4, P5 p5,
  1003.       P6 p6, P7 p7, P8 p8, P9 p9, P10 p10,
  1004.       P11 p11, P12 p12, P13 p13, P14 p14, P15 p15,
  1005.       P16 p16, P17 p17, P18 p18, P19 p19, P20 p20,
  1006.       P21 p21, P22 p22, P23 p23, P24 p24);
  1007.  
  1008.     template <class P1, class P2, class P3, class P4, class P5,
  1009.               class P6, class P7, class P8, class P9, class P10,
  1010.               class P11, class P12, class P13, class P14, class P15,
  1011.               class P16, class P17, class P18, class P19, class P20,
  1012.               class P21, class P22, class P23, class P24, class P25>
  1013.     Variant OleFunction(const String& name,
  1014.       P1 p1, P2 p2, P3 p3, P4 p4, P5 p5,
  1015.       P6 p6, P7 p7, P8 p8, P9 p9, P10 p10,
  1016.       P11 p11, P12 p12, P13 p13, P14 p14, P15 p15,
  1017.       P16 p16, P17 p17, P18 p18, P19 p19, P20 p20,
  1018.       P21 p21, P22 p22, P23 p23, P24 p24, P25 p25);
  1019.  
  1020.     template <class P1, class P2, class P3, class P4, class P5,
  1021.               class P6, class P7, class P8, class P9, class P10,
  1022.               class P11, class P12, class P13, class P14, class P15,
  1023.               class P16, class P17, class P18, class P19, class P20,
  1024.               class P21, class P22, class P23, class P24, class P25,
  1025.               class P26>
  1026.     Variant OleFunction(const String& name,
  1027.       P1 p1, P2 p2, P3 p3, P4 p4, P5 p5,
  1028.       P6 p6, P7 p7, P8 p8, P9 p9, P10 p10,
  1029.       P11 p11, P12 p12, P13 p13, P14 p14, P15 p15,
  1030.       P16 p16, P17 p17, P18 p18, P19 p19, P20 p20,
  1031.       P21 p21, P22 p22, P23 p23, P24 p24, P25 p25,
  1032.       P26 p26);
  1033.  
  1034.     template <class P1, class P2, class P3, class P4, class P5,
  1035.               class P6, class P7, class P8, class P9, class P10,
  1036.               class P11, class P12, class P13, class P14, class P15,
  1037.               class P16, class P17, class P18, class P19, class P20,
  1038.               class P21, class P22, class P23, class P24, class P25,
  1039.               class P26, class P27>
  1040.     Variant OleFunction(const String& name,
  1041.       P1 p1, P2 p2, P3 p3, P4 p4, P5 p5,
  1042.       P6 p6, P7 p7, P8 p8, P9 p9, P10 p10,
  1043.       P11 p11, P12 p12, P13 p13, P14 p14, P15 p15,
  1044.       P16 p16, P17 p17, P18 p18, P19 p19, P20 p20,
  1045.       P21 p21, P22 p22, P23 p23, P24 p24, P25 p25,
  1046.       P26 p26, P27 p27);
  1047.  
  1048.     template <class P1, class P2, class P3, class P4, class P5,
  1049.               class P6, class P7, class P8, class P9, class P10,
  1050.               class P11, class P12, class P13, class P14, class P15,
  1051.               class P16, class P17, class P18, class P19, class P20,
  1052.               class P21, class P22, class P23, class P24, class P25,
  1053.               class P26, class P27, class P28>
  1054.     Variant OleFunction(const String& name,
  1055.       P1 p1, P2 p2, P3 p3, P4 p4, P5 p5,
  1056.       P6 p6, P7 p7, P8 p8, P9 p9, P10 p10,
  1057.       P11 p11, P12 p12, P13 p13, P14 p14, P15 p15,
  1058.       P16 p16, P17 p17, P18 p18, P19 p19, P20 p20,
  1059.       P21 p21, P22 p22, P23 p23, P24 p24, P25 p25,
  1060.       P26 p26, P27 p27, P28 p28);
  1061.  
  1062.     template <class P1, class P2, class P3, class P4, class P5,
  1063.               class P6, class P7, class P8, class P9, class P10,
  1064.               class P11, class P12, class P13, class P14, class P15,
  1065.               class P16, class P17, class P18, class P19, class P20,
  1066.               class P21, class P22, class P23, class P24, class P25,
  1067.               class P26, class P27, class P28, class P29>
  1068.     Variant OleFunction(const String& name,
  1069.       P1 p1, P2 p2, P3 p3, P4 p4, P5 p5,
  1070.       P6 p6, P7 p7, P8 p8, P9 p9, P10 p10,
  1071.       P11 p11, P12 p12, P13 p13, P14 p14, P15 p15,
  1072.       P16 p16, P17 p17, P18 p18, P19 p19, P20 p20,
  1073.       P21 p21, P22 p22, P23 p23, P24 p24, P25 p25,
  1074.       P26 p26, P27 p27, P28 p28, P29 p29);
  1075.  
  1076.     template <class P1, class P2, class P3, class P4, class P5,
  1077.               class P6, class P7, class P8, class P9, class P10,
  1078.               class P11, class P12, class P13, class P14, class P15,
  1079.               class P16, class P17, class P18, class P19, class P20,
  1080.               class P21, class P22, class P23, class P24, class P25,
  1081.               class P26, class P27, class P28, class P29, class P30>
  1082.     Variant OleFunction(const String& name,
  1083.       P1 p1, P2 p2, P3 p3, P4 p4, P5 p5,
  1084.       P6 p6, P7 p7, P8 p8, P9 p9, P10 p10,
  1085.       P11 p11, P12 p12, P13 p13, P14 p14, P15 p15,
  1086.       P16 p16, P17 p17, P18 p18, P19 p19, P20 p20,
  1087.       P21 p21, P22 p22, P23 p23, P24 p24, P25 p25,
  1088.       P26 p26, P27 p27, P28 p28, P29 p29, P30 p30);
  1089.  
  1090.     template <class P1, class P2, class P3, class P4, class P5,
  1091.               class P6, class P7, class P8, class P9, class P10,
  1092.               class P11, class P12, class P13, class P14, class P15,
  1093.               class P16, class P17, class P18, class P19, class P20,
  1094.               class P21, class P22, class P23, class P24, class P25,
  1095.               class P26, class P27, class P28, class P29, class P30,
  1096.               class P31>
  1097.     Variant OleFunction(const String& name,
  1098.       P1 p1, P2 p2, P3 p3, P4 p4, P5 p5,
  1099.       P6 p6, P7 p7, P8 p8, P9 p9, P10 p10,
  1100.       P11 p11, P12 p12, P13 p13, P14 p14, P15 p15,
  1101.       P16 p16, P17 p17, P18 p18, P19 p19, P20 p20,
  1102.       P21 p21, P22 p22, P23 p23, P24 p24, P25 p25,
  1103.       P26 p26, P27 p27, P28 p28, P29 p29, P30 p30,
  1104.       P31 p31);
  1105.  
  1106.     template <class P1, class P2, class P3, class P4, class P5,
  1107.               class P6, class P7, class P8, class P9, class P10,
  1108.               class P11, class P12, class P13, class P14, class P15,
  1109.               class P16, class P17, class P18, class P19, class P20,
  1110.               class P21, class P22, class P23, class P24, class P25,
  1111.               class P26, class P27, class P28, class P29, class P30,
  1112.               class P31, class P32>
  1113.     Variant OleFunction(const String& name,
  1114.       P1 p1, P2 p2, P3 p3, P4 p4, P5 p5,
  1115.       P6 p6, P7 p7, P8 p8, P9 p9, P10 p10,
  1116.       P11 p11, P12 p12, P13 p13, P14 p14, P15 p15,
  1117.       P16 p16, P17 p17, P18 p18, P19 p19, P20 p20,
  1118.       P21 p21, P22 p22, P23 p23, P24 p24, P25 p25,
  1119.       P26 p26, P27 p27, P28 p28, P29 p29, P30 p30,
  1120.       P31 p31, P32 p32);
  1121.  
  1122.     template <class P1>
  1123.     Variant OlePropertyGet(const String& name, P1 p1);
  1124.  
  1125.     template <class P1, class P2>
  1126.     Variant OlePropertyGet(const String& name, P1 p1, P2 p2);
  1127.  
  1128.     template <class P1, class P2, class P3>
  1129.     Variant OlePropertyGet(const String& name, P1 p1, P2 p2, P3 p3);
  1130.  
  1131.     template <class P1, class P2, class P3, class P4>
  1132.     Variant OlePropertyGet(const String& name, P1 p1, P2 p2, P3 p3, P4 p4);
  1133.  
  1134.     template <class P1, class P2, class P3, class P4, class P5>
  1135.     Variant OlePropertyGet(const String& name, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5);
  1136.  
  1137.     template <class P1, class P2, class P3, class P4, class P5,
  1138.               class P6>
  1139.     Variant OlePropertyGet(const String& name,
  1140.       P1 p1, P2 p2, P3 p3, P4 p4, P5 p5,
  1141.       P6 p6);
  1142.  
  1143.     template <class P1, class P2, class P3, class P4, class P5,
  1144.               class P6, class P7>
  1145.     Variant OlePropertyGet(const String& name,
  1146.       P1 p1, P2 p2, P3 p3, P4 p4, P5 p5,
  1147.       P6 p6, P7 p7);
  1148.  
  1149.     template <class P1, class P2, class P3, class P4, class P5,
  1150.               class P6, class P7, class P8>
  1151.     Variant OlePropertyGet(const String& name,
  1152.       P1 p1, P2 p2, P3 p3, P4 p4, P5 p5,
  1153.       P6 p6, P7 p7, P8 p8);
  1154.  
  1155.     template <class P1, class P2, class P3, class P4, class P5,
  1156.               class P6, class P7, class P8, class P9>
  1157.     Variant OlePropertyGet(const String& name,
  1158.       P1 p1, P2 p2, P3 p3, P4 p4, P5 p5,
  1159.       P6 p6, P7 p7, P8 p8, P9 p9);
  1160.  
  1161.     template <class P1, class P2, class P3, class P4, class P5,
  1162.               class P6, class P7, class P8, class P9, class P10>
  1163.     Variant OlePropertyGet(const String& name,
  1164.       P1 p1, P2 p2, P3 p3, P4 p4, P5 p5,
  1165.       P6 p6, P7 p7, P8 p8, P9 p9, P10 p10);
  1166.  
  1167.     template <class P1>
  1168.     void OlePropertySet(const String& name, P1 p1);
  1169.  
  1170.     template <class P1, class P2>
  1171.     void OlePropertySet(const String& name, P1 p1, P2 p2);
  1172.  
  1173.     template <class P1, class P2, class P3>
  1174.     void OlePropertySet(const String& name, P1 p1, P2 p2, P3 p3);
  1175.  
  1176.     template <class P1, class P2, class P3, class P4>
  1177.     void OlePropertySet(const String& name, P1 p1, P2 p2, P3 p3, P4 p4);
  1178.  
  1179.     template <class P1, class P2, class P3, class P4, class P5>
  1180.     void OlePropertySet(const String& name, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5);
  1181.  
  1182.     template <class P1, class P2, class P3, class P4, class P5,
  1183.               class P6>
  1184.     void OlePropertySet(const String& name,
  1185.       P1 p1, P2 p2, P3 p3, P4 p4, P5 p5,
  1186.       P6 p6);
  1187.  
  1188.     template <class P1, class P2, class P3, class P4, class P5,
  1189.               class P6, class P7>
  1190.     void OlePropertySet(const String& name,
  1191.       P1 p1, P2 p2, P3 p3, P4 p4, P5 p5,
  1192.       P6 p6, P7 p7);
  1193.  
  1194.     template <class P1, class P2, class P3, class P4, class P5,
  1195.               class P6, class P7, class P8>
  1196.     void OlePropertySet(const String& name,
  1197.       P1 p1, P2 p2, P3 p3, P4 p4, P5 p5,
  1198.       P6 p6, P7 p7, P8 p8);
  1199.  
  1200.     template <class P1, class P2, class P3, class P4, class P5,
  1201.               class P6, class P7, class P8, class P9>
  1202.     void OlePropertySet(const String& name,
  1203.       P1 p1, P2 p2, P3 p3, P4 p4, P5 p5,
  1204.       P6 p6, P7 p7, P8 p8, P9 p9);
  1205.  
  1206.     template <class P1, class P2, class P3, class P4, class P5,
  1207.               class P6, class P7, class P8, class P9, class P10>
  1208.     void OlePropertySet(const String& name,
  1209.       P1 p1, P2 p2, P3 p3, P4 p4, P5 p5,
  1210.       P6 p6, P7 p7, P8 p8, P9 p9, P10 p10);
  1211.  
  1212.  
  1213.     // End of Alternate Syntax for Automation
  1214.  
  1215.     // Ref. to Variant which can be used for non-specified optional parameters or 'Empty' parameters
  1216.     static Variant& NoParam();
  1217.     static Variant& Empty();
  1218.  
  1219.   private:
  1220.     // AutoCmd::GetParm & GetNamedParm uses operator [] (AutoCmd is a friend)
  1221.     // operator[] can only be used for arrays of type Variant
  1222.     Variant& __fastcall operator [](const int idx);
  1223.   };
  1224.  
  1225.  
  1226.  
  1227.   template <class P1>
  1228.   void Variant::OleProcedure(const String& name, P1 p1)
  1229.   {
  1230.     TAutoArgs<1> args;
  1231.     args[1] = p1;
  1232.     OleProcedure(name, static_cast<TAutoArgsBase*>(&args));
  1233.   }
  1234.  
  1235.   template <class P1, class P2>
  1236.   void Variant::OleProcedure(const String& name, P1 p1, P2 p2)
  1237.   {
  1238.     TAutoArgs<2> args;
  1239.     args[1] = p1;  args[2] = p2;
  1240.     OleProcedure(name, static_cast<TAutoArgsBase*>(&args));
  1241.   }
  1242.  
  1243.   template <class P1, class P2, class P3>
  1244.   void Variant::OleProcedure(const String& name, P1 p1, P2 p2, P3 p3)
  1245.   {
  1246.     TAutoArgs<3> args;
  1247.     args[1] = p1;  args[2] = p2;  args[3] = p3;
  1248.     OleProcedure(name, static_cast<TAutoArgsBase*>(&args));
  1249.   }
  1250.  
  1251.   template <class P1, class P2, class P3, class P4>
  1252.   void Variant::OleProcedure(const String& name, P1 p1, P2 p2, P3 p3, P4 p4)
  1253.   {
  1254.     TAutoArgs<4> args;
  1255.     args[1] = p1;  args[2] = p2;  args[3] = p3;
  1256.     args[4] = p4;
  1257.     OleProcedure(name, static_cast<TAutoArgsBase*>(&args));
  1258.   }
  1259.  
  1260.   template <class P1, class P2, class P3, class P4, class P5>
  1261.   void Variant::OleProcedure(const String& name, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
  1262.   {
  1263.     TAutoArgs<5> args;
  1264.     args[1] = p1;  args[2] = p2;  args[3] = p3;
  1265.     args[4] = p4;  args[5] = p5;
  1266.     OleProcedure(name, static_cast<TAutoArgsBase*>(&args));
  1267.   }
  1268.  
  1269.   template <class P1, class P2, class P3, class P4, class P5,
  1270.             class P6>
  1271.   void Variant::OleProcedure(const String& name,
  1272.     P1 p1, P2 p2, P3 p3, P4 p4, P5 p5,
  1273.     P6 p6)
  1274.   {
  1275.     TAutoArgs<6> args;
  1276.     args[1] = p1;  args[2] = p2;  args[3] = p3;
  1277.     args[4] = p4;  args[5] = p5;  args[6] = p6;
  1278.     OleProcedure(name, static_cast<TAutoArgsBase*>(&args));
  1279.   }
  1280.  
  1281.   template <class P1, class P2, class P3, class P4, class P5,
  1282.             class P6, class P7>
  1283.   void Variant::OleProcedure(const String& name,
  1284.     P1 p1, P2 p2, P3 p3, P4 p4, P5 p5,
  1285.     P6 p6, P7 p7)
  1286.   {
  1287.     TAutoArgs<7> args;
  1288.     args[1] = p1;  args[2] = p2;  args[3] = p3;
  1289.     args[4] = p4;  args[5] = p5;  args[6] = p6;
  1290.     args[7] = p7;
  1291.     OleProcedure(name, static_cast<TAutoArgsBase*>(&args));
  1292.   }
  1293.  
  1294.   template <class P1, class P2, class P3, class P4, class P5,
  1295.             class P6, class P7, class P8>
  1296.   void Variant::OleProcedure(const String& name,
  1297.     P1 p1, P2 p2, P3 p3, P4 p4, P5 p5,
  1298.     P6 p6, P7 p7, P8 p8)
  1299.   {
  1300.     TAutoArgs<8> args;
  1301.     args[1] = p1;  args[2] = p2;  args[3] = p3;
  1302.     args[4] = p4;  args[5] = p5;  args[6] = p6;
  1303.     args[7] = p7;  args[8] = p8;
  1304.     OleProcedure(name, static_cast<TAutoArgsBase*>(&args));
  1305.   }
  1306.  
  1307.   template <class P1, class P2, class P3, class P4, class P5,
  1308.             class P6, class P7, class P8, class P9>
  1309.   void Variant::OleProcedure(const String& name,
  1310.     P1 p1, P2 p2, P3 p3, P4 p4, P5 p5,
  1311.     P6 p6, P7 p7, P8 p8, P9 p9)
  1312.   {
  1313.     TAutoArgs<9> args;
  1314.     args[1] = p1;  args[2] = p2;  args[3] = p3;
  1315.     args[4] = p4;  args[5] = p5;  args[6] = p6;
  1316.     args[7] = p7;  args[8] = p8;  args[9] = p9;
  1317.     OleProcedure(name, static_cast<TAutoArgsBase*>(&args));
  1318.   }
  1319.  
  1320.   template <class P1, class P2, class P3, class P4, class P5,
  1321.             class P6, class P7, class P8, class P9, class P10>
  1322.   void Variant::OleProcedure(const String& name,
  1323.     P1 p1, P2 p2, P3 p3, P4 p4, P5 p5,
  1324.     P6 p6, P7 p7, P8 p8, P9 p9, P10 p10)
  1325.   {
  1326.     TAutoArgs<10> args;
  1327.     args[1] = p1;  args[2] = p2;  args[3] = p3;
  1328.     args[4] = p4;  args[5] = p5;  args[6] = p6;
  1329.     args[7] = p7;  args[8] = p8;  args[9] = p9;
  1330.     args[10] = p10;
  1331.     OleProcedure(name, static_cast<TAutoArgsBase*>(&args));
  1332.   }
  1333.  
  1334.   template <class P1, class P2, class P3, class P4, class P5,
  1335.             class P6, class P7, class P8, class P9, class P10,
  1336.             class P11>
  1337.   void Variant::OleProcedure(const String& name,
  1338.     P1 p1, P2 p2, P3 p3, P4 p4, P5 p5,
  1339.     P6 p6, P7 p7, P8 p8, P9 p9, P10 p10,
  1340.     P11 p11)
  1341.   {
  1342.     TAutoArgs<11> args;
  1343.     args[1] = p1;  args[2] = p2;  args[3] = p3;
  1344.     args[4] = p4;  args[5] = p5;  args[6] = p6;
  1345.     args[7] = p7;  args[8] = p8;  args[9] = p9;
  1346.     args[10] = p10;  args[11] = p11;
  1347.     OleProcedure(name, static_cast<TAutoArgsBase*>(&args));
  1348.   }
  1349.  
  1350.   template <class P1, class P2, class P3, class P4, class P5,
  1351.             class P6, class P7, class P8, class P9, class P10,
  1352.             class P11, class P12>
  1353.   void Variant::OleProcedure(const String& name,
  1354.     P1 p1, P2 p2, P3 p3, P4 p4, P5 p5,
  1355.     P6 p6, P7 p7, P8 p8, P9 p9, P10 p10,
  1356.     P11 p11, P12 p12)
  1357.   {
  1358.     TAutoArgs<12> args;
  1359.     args[1] = p1;  args[2] = p2;  args[3] = p3;
  1360.     args[4] = p4;  args[5] = p5;  args[6] = p6;
  1361.     args[7] = p7;  args[8] = p8;  args[9] = p9;
  1362.     args[10] = p10;  args[11] = p11;  args[12] = p12;
  1363.     OleProcedure(name, static_cast<TAutoArgsBase*>(&args));
  1364.   }
  1365.  
  1366.   template <class P1, class P2, class P3, class P4, class P5,
  1367.             class P6, class P7, class P8, class P9, class P10,
  1368.             class P11, class P12, class P13>
  1369.   void Variant::OleProcedure(const String& name,
  1370.     P1 p1, P2 p2, P3 p3, P4 p4, P5 p5,
  1371.     P6 p6, P7 p7, P8 p8, P9 p9, P10 p10,
  1372.     P11 p11, P12 p12, P13 p13)
  1373.   {
  1374.     TAutoArgs<13> args;
  1375.     args[1] = p1;  args[2] = p2;  args[3] = p3;
  1376.     args[4] = p4;  args[5] = p5;  args[6] = p6;
  1377.     args[7] = p7;  args[8] = p8;  args[9] = p9;
  1378.     args[10] = p10;  args[11] = p11;  args[12] = p12;
  1379.     args[13] = p13;
  1380.     OleProcedure(name, static_cast<TAutoArgsBase*>(&args));
  1381.   }
  1382.  
  1383.   template <class P1, class P2, class P3, class P4, class P5,
  1384.             class P6, class P7, class P8, class P9, class P10,
  1385.             class P11, class P12, class P13, class P14>
  1386.   void Variant::OleProcedure(const String& name,
  1387.     P1 p1, P2 p2, P3 p3, P4 p4, P5 p5,
  1388.     P6 p6, P7 p7, P8 p8, P9 p9, P10 p10,
  1389.     P11 p11, P12 p12, P13 p13, P14 p14)
  1390.   {
  1391.     TAutoArgs<14> args;
  1392.     args[1] = p1;  args[2] = p2;  args[3] = p3;
  1393.     args[4] = p4;  args[5] = p5;  args[6] = p6;
  1394.     args[7] = p7;  args[8] = p8;  args[9] = p9;
  1395.     args[10] = p10;  args[11] = p11;  args[12] = p12;
  1396.     args[13] = p13;  args[14] = p14;
  1397.     OleProcedure(name, static_cast<TAutoArgsBase*>(&args));
  1398.   }
  1399.  
  1400.   template <class P1, class P2, class P3, class P4, class P5,
  1401.             class P6, class P7, class P8, class P9, class P10,
  1402.             class P11, class P12, class P13, class P14, class P15>
  1403.   void Variant::OleProcedure(const String& name,
  1404.     P1 p1, P2 p2, P3 p3, P4 p4, P5 p5,
  1405.     P6 p6, P7 p7, P8 p8, P9 p9, P10 p10,
  1406.     P11 p11, P12 p12, P13 p13, P14 p14, P15 p15)
  1407.   {
  1408.     TAutoArgs<15> args;
  1409.     args[1] = p1;  args[2] = p2;  args[3] = p3;
  1410.     args[4] = p4;  args[5] = p5;  args[6] = p6;
  1411.     args[7] = p7;  args[8] = p8;  args[9] = p9;
  1412.     args[10] = p10;  args[11] = p11;  args[12] = p12;
  1413.     args[13] = p13;  args[14] = p14;  args[15] = p15;
  1414.     OleProcedure(name, static_cast<TAutoArgsBase*>(&args));
  1415.   }
  1416.  
  1417.   template <class P1, class P2, class P3, class P4, class P5,
  1418.             class P6, class P7, class P8, class P9, class P10,
  1419.             class P11, class P12, class P13, class P14, class P15,
  1420.             class P16>
  1421.   void Variant::OleProcedure(const String& name,
  1422.     P1 p1, P2 p2, P3 p3, P4 p4, P5 p5,
  1423.     P6 p6, P7 p7, P8 p8, P9 p9, P10 p10,
  1424.     P11 p11, P12 p12, P13 p13, P14 p14, P15 p15,
  1425.     P16 p16)
  1426.   {
  1427.     TAutoArgs<16> args;
  1428.     args[1] = p1;  args[2] = p2;  args[3] = p3;
  1429.     args[4] = p4;  args[5] = p5;  args[6] = p6;
  1430.     args[7] = p7;  args[8] = p8;  args[9] = p9;
  1431.     args[10] = p10;  args[11] = p11;  args[12] = p12;
  1432.     args[13] = p13;  args[14] = p14;  args[15] = p15;
  1433.     args[16] = p16;
  1434.     OleProcedure(name, static_cast<TAutoArgsBase*>(&args));
  1435.   }
  1436.  
  1437.   template <class P1, class P2, class P3, class P4, class P5,
  1438.             class P6, class P7, class P8, class P9, class P10,
  1439.             class P11, class P12, class P13, class P14, class P15,
  1440.             class P16, class P17>
  1441.   void Variant::OleProcedure(const String& name,
  1442.     P1 p1, P2 p2, P3 p3, P4 p4, P5 p5,
  1443.     P6 p6, P7 p7, P8 p8, P9 p9, P10 p10,
  1444.     P11 p11, P12 p12, P13 p13, P14 p14, P15 p15,
  1445.     P16 p16, P17 p17)
  1446.   {
  1447.     TAutoArgs<17> args;
  1448.     args[1] = p1;  args[2] = p2;  args[3] = p3;
  1449.     args[4] = p4;  args[5] = p5;  args[6] = p6;
  1450.     args[7] = p7;  args[8] = p8;  args[9] = p9;
  1451.     args[10] = p10;  args[11] = p11;  args[12] = p12;
  1452.     args[13] = p13;  args[14] = p14;  args[15] = p15;
  1453.     args[16] = p16;  args[17] = p17;
  1454.     OleProcedure(name, static_cast<TAutoArgsBase*>(&args));
  1455.   }
  1456.  
  1457.   template <class P1, class P2, class P3, class P4, class P5,
  1458.             class P6, class P7, class P8, class P9, class P10,
  1459.             class P11, class P12, class P13, class P14, class P15,
  1460.             class P16, class P17, class P18>
  1461.   void Variant::OleProcedure(const String& name,
  1462.     P1 p1, P2 p2, P3 p3, P4 p4, P5 p5,
  1463.     P6 p6, P7 p7, P8 p8, P9 p9, P10 p10,
  1464.     P11 p11, P12 p12, P13 p13, P14 p14, P15 p15,
  1465.     P16 p16, P17 p17, P18 p18)
  1466.   {
  1467.     TAutoArgs<18> args;
  1468.     args[1] = p1;  args[2] = p2;  args[3] = p3;
  1469.     args[4] = p4;  args[5] = p5;  args[6] = p6;
  1470.     args[7] = p7;  args[8] = p8;  args[9] = p9;
  1471.     args[10] = p10;  args[11] = p11;  args[12] = p12;
  1472.     args[13] = p13;  args[14] = p14;  args[15] = p15;
  1473.     args[16] = p16;  args[17] = p17;  args[18] = p18;
  1474.     OleProcedure(name, static_cast<TAutoArgsBase*>(&args));
  1475.   }
  1476.  
  1477.   template <class P1, class P2, class P3, class P4, class P5,
  1478.             class P6, class P7, class P8, class P9, class P10,
  1479.             class P11, class P12, class P13, class P14, class P15,
  1480.             class P16, class P17, class P18, class P19>
  1481.   void Variant::OleProcedure(const String& name,
  1482.     P1 p1, P2 p2, P3 p3, P4 p4, P5 p5,
  1483.     P6 p6, P7 p7, P8 p8, P9 p9, P10 p10,
  1484.     P11 p11, P12 p12, P13 p13, P14 p14, P15 p15,
  1485.     P16 p16, P17 p17, P18 p18, P19 p19)
  1486.   {
  1487.     TAutoArgs<19> args;
  1488.     args[1] = p1;  args[2] = p2;  args[3] = p3;
  1489.     args[4] = p4;  args[5] = p5;  args[6] = p6;
  1490.     args[7] = p7;  args[8] = p8;  args[9] = p9;
  1491.     args[10] = p10;  args[11] = p11;  args[12] = p12;
  1492.     args[13] = p13;  args[14] = p14;  args[15] = p15;
  1493.     args[16] = p16;  args[17] = p17;  args[18] = p18;
  1494.     args[19] = p19;
  1495.     OleProcedure(name, static_cast<TAutoArgsBase*>(&args));
  1496.   }
  1497.  
  1498.   template <class P1, class P2, class P3, class P4, class P5,
  1499.             class P6, class P7, class P8, class P9, class P10,
  1500.             class P11, class P12, class P13, class P14, class P15,
  1501.             class P16, class P17, class P18, class P19, class P20>
  1502.   void Variant::OleProcedure(const String& name,
  1503.     P1 p1, P2 p2, P3 p3, P4 p4, P5 p5,
  1504.     P6 p6, P7 p7, P8 p8, P9 p9, P10 p10,
  1505.     P11 p11, P12 p12, P13 p13, P14 p14, P15 p15,
  1506.     P16 p16, P17 p17, P18 p18, P19 p19, P20 p20)
  1507.   {
  1508.     TAutoArgs<20> args;
  1509.     args[1] = p1;  args[2] = p2;  args[3] = p3;
  1510.     args[4] = p4;  args[5] = p5;  args[6] = p6;
  1511.     args[7] = p7;  args[8] = p8;  args[9] = p9;
  1512.     args[10] = p10;  args[11] = p11;  args[12] = p12;
  1513.     args[13] = p13;  args[14] = p14;  args[15] = p15;
  1514.     args[16] = p16;  args[17] = p17;  args[18] = p18;
  1515.     args[19] = p19;  args[20] = p20;
  1516.     OleProcedure(name, static_cast<TAutoArgsBase*>(&args));
  1517.   }
  1518.  
  1519.   template <class P1, class P2, class P3, class P4, class P5,
  1520.             class P6, class P7, class P8, class P9, class P10,
  1521.             class P11, class P12, class P13, class P14, class P15,
  1522.             class P16, class P17, class P18, class P19, class P20,
  1523.             class P21>
  1524.   void Variant::OleProcedure(const String& name,
  1525.     P1 p1, P2 p2, P3 p3, P4 p4, P5 p5,
  1526.     P6 p6, P7 p7, P8 p8, P9 p9, P10 p10,
  1527.     P11 p11, P12 p12, P13 p13, P14 p14, P15 p15,
  1528.     P16 p16, P17 p17, P18 p18, P19 p19, P20 p20,
  1529.     P21 p21)
  1530.   {
  1531.     TAutoArgs<21> args;
  1532.     args[1] = p1;  args[2] = p2;  args[3] = p3;
  1533.     args[4] = p4;  args[5] = p5;  args[6] = p6;
  1534.     args[7] = p7;  args[8] = p8;  args[9] = p9;
  1535.     args[10] = p10;  args[11] = p11;  args[12] = p12;
  1536.     args[13] = p13;  args[14] = p14;  args[15] = p15;
  1537.     args[16] = p16;  args[17] = p17;  args[18] = p18;
  1538.     args[19] = p19;  args[20] = p20;  args[21] = p21;
  1539.     OleProcedure(name, static_cast<TAutoArgsBase*>(&args));
  1540.   }
  1541.  
  1542.   template <class P1, class P2, class P3, class P4, class P5,
  1543.             class P6, class P7, class P8, class P9, class P10,
  1544.             class P11, class P12, class P13, class P14, class P15,
  1545.             class P16, class P17, class P18, class P19, class P20,
  1546.             class P21, class P22>
  1547.   void Variant::OleProcedure(const String& name,
  1548.     P1 p1, P2 p2, P3 p3, P4 p4, P5 p5,
  1549.     P6 p6, P7 p7, P8 p8, P9 p9, P10 p10,
  1550.     P11 p11, P12 p12, P13 p13, P14 p14, P15 p15,
  1551.     P16 p16, P17 p17, P18 p18, P19 p19, P20 p20,
  1552.     P21 p21, P22 p22)
  1553.   {
  1554.     TAutoArgs<22> args;
  1555.     args[1] = p1;  args[2] = p2;  args[3] = p3;
  1556.     args[4] = p4;  args[5] = p5;  args[6] = p6;
  1557.     args[7] = p7;  args[8] = p8;  args[9] = p9;
  1558.     args[10] = p10;  args[11] = p11;  args[12] = p12;
  1559.     args[13] = p13;  args[14] = p14;  args[15] = p15;
  1560.     args[16] = p16;  args[17] = p17;  args[18] = p18;
  1561.     args[19] = p19;  args[20] = p20;  args[21] = p21;
  1562.     args[22] = p22;
  1563.     OleProcedure(name, static_cast<TAutoArgsBase*>(&args));
  1564.   }
  1565.  
  1566.   template <class P1, class P2, class P3, class P4, class P5,
  1567.             class P6, class P7, class P8, class P9, class P10,
  1568.             class P11, class P12, class P13, class P14, class P15,
  1569.             class P16, class P17, class P18, class P19, class P20,
  1570.             class P21, class P22, class P23>
  1571.   void Variant::OleProcedure(const String& name,
  1572.     P1 p1, P2 p2, P3 p3, P4 p4, P5 p5,
  1573.     P6 p6, P7 p7, P8 p8, P9 p9, P10 p10,
  1574.     P11 p11, P12 p12, P13 p13, P14 p14, P15 p15,
  1575.     P16 p16, P17 p17, P18 p18, P19 p19, P20 p20,
  1576.     P21 p21, P22 p22, P23 p23)
  1577.   {
  1578.     TAutoArgs<23> args;
  1579.     args[1] = p1;  args[2] = p2;  args[3] = p3;
  1580.     args[4] = p4;  args[5] = p5;  args[6] = p6;
  1581.     args[7] = p7;  args[8] = p8;  args[9] = p9;
  1582.     args[10] = p10;  args[11] = p11;  args[12] = p12;
  1583.     args[13] = p13;  args[14] = p14;  args[15] = p15;
  1584.     args[16] = p16;  args[17] = p17;  args[18] = p18;
  1585.     args[19] = p19;  args[20] = p20;  args[21] = p21;
  1586.     args[22] = p22;  args[23] = p23;
  1587.     OleProcedure(name, static_cast<TAutoArgsBase*>(&args));
  1588.   }
  1589.  
  1590.   template <class P1, class P2, class P3, class P4, class P5,
  1591.             class P6, class P7, class P8, class P9, class P10,
  1592.             class P11, class P12, class P13, class P14, class P15,
  1593.             class P16, class P17, class P18, class P19, class P20,
  1594.             class P21, class P22, class P23, class P24>
  1595.   void Variant::OleProcedure(const String& name,
  1596.     P1 p1, P2 p2, P3 p3, P4 p4, P5 p5,
  1597.     P6 p6, P7 p7, P8 p8, P9 p9, P10 p10,
  1598.     P11 p11, P12 p12, P13 p13, P14 p14, P15 p15,
  1599.     P16 p16, P17 p17, P18 p18, P19 p19, P20 p20,
  1600.     P21 p21, P22 p22, P23 p23, P24 p24)
  1601.   {
  1602.     TAutoArgs<24> args;
  1603.     args[1] = p1;  args[2] = p2;  args[3] = p3;
  1604.     args[4] = p4;  args[5] = p5;  args[6] = p6;
  1605.     args[7] = p7;  args[8] = p8;  args[9] = p9;
  1606.     args[10] = p10;  args[11] = p11;  args[12] = p12;
  1607.     args[13] = p13;  args[14] = p14;  args[15] = p15;
  1608.     args[16] = p16;  args[17] = p17;  args[18] = p18;
  1609.     args[19] = p19;  args[20] = p20;  args[21] = p21;
  1610.     args[22] = p22;  args[23] = p23;  args[24] = p24;
  1611.     OleProcedure(name, static_cast<TAutoArgsBase*>(&args));
  1612.   }
  1613.  
  1614.   template <class P1, class P2, class P3, class P4, class P5,
  1615.             class P6, class P7, class P8, class P9, class P10,
  1616.             class P11, class P12, class P13, class P14, class P15,
  1617.             class P16, class P17, class P18, class P19, class P20,
  1618.             class P21, class P22, class P23, class P24, class P25>
  1619.   void Variant::OleProcedure(const String& name,
  1620.     P1 p1, P2 p2, P3 p3, P4 p4, P5 p5,
  1621.     P6 p6, P7 p7, P8 p8, P9 p9, P10 p10,
  1622.     P11 p11, P12 p12, P13 p13, P14 p14, P15 p15,
  1623.     P16 p16, P17 p17, P18 p18, P19 p19, P20 p20,
  1624.     P21 p21, P22 p22, P23 p23, P24 p24, P25 p25)
  1625.   {
  1626.     TAutoArgs<25> args;
  1627.     args[1] = p1;  args[2] = p2;  args[3] = p3;
  1628.     args[4] = p4;  args[5] = p5;  args[6] = p6;
  1629.     args[7] = p7;  args[8] = p8;  args[9] = p9;
  1630.     args[10] = p10;  args[11] = p11;  args[12] = p12;
  1631.     args[13] = p13;  args[14] = p14;  args[15] = p15;
  1632.     args[16] = p16;  args[17] = p17;  args[18] = p18;
  1633.     args[19] = p19;  args[20] = p20;  args[21] = p21;
  1634.     args[22] = p22;  args[23] = p23;  args[24] = p24;
  1635.     args[25] = p25;
  1636.     OleProcedure(name, static_cast<TAutoArgsBase*>(&args));
  1637.   }
  1638.  
  1639.   template <class P1, class P2, class P3, class P4, class P5,
  1640.             class P6, class P7, class P8, class P9, class P10,
  1641.             class P11, class P12, class P13, class P14, class P15,
  1642.             class P16, class P17, class P18, class P19, class P20,
  1643.             class P21, class P22, class P23, class P24, class P25,
  1644.             class P26>
  1645.   void Variant::OleProcedure(const String& name,
  1646.     P1 p1, P2 p2, P3 p3, P4 p4, P5 p5,
  1647.     P6 p6, P7 p7, P8 p8, P9 p9, P10 p10,
  1648.     P11 p11, P12 p12, P13 p13, P14 p14, P15 p15,
  1649.     P16 p16, P17 p17, P18 p18, P19 p19, P20 p20,
  1650.     P21 p21, P22 p22, P23 p23, P24 p24, P25 p25,
  1651.     P26 p26)
  1652.   {
  1653.     TAutoArgs<26> args;
  1654.     args[1] = p1;  args[2] = p2;  args[3] = p3;
  1655.     args[4] = p4;  args[5] = p5;  args[6] = p6;
  1656.     args[7] = p7;  args[8] = p8;  args[9] = p9;
  1657.     args[10] = p10;  args[11] = p11;  args[12] = p12;
  1658.     args[13] = p13;  args[14] = p14;  args[15] = p15;
  1659.     args[16] = p16;  args[17] = p17;  args[18] = p18;
  1660.     args[19] = p19;  args[20] = p20;  args[21] = p21;
  1661.     args[22] = p22;  args[23] = p23;  args[24] = p24;
  1662.     args[25] = p25;  args[26] = p26;
  1663.     OleProcedure(name, static_cast<TAutoArgsBase*>(&args));
  1664.   }
  1665.  
  1666.   template <class P1, class P2, class P3, class P4, class P5,
  1667.             class P6, class P7, class P8, class P9, class P10,
  1668.             class P11, class P12, class P13, class P14, class P15,
  1669.             class P16, class P17, class P18, class P19, class P20,
  1670.             class P21, class P22, class P23, class P24, class P25,
  1671.             class P26, class P27>
  1672.   void Variant::OleProcedure(const String& name,
  1673.     P1 p1, P2 p2, P3 p3, P4 p4, P5 p5,
  1674.     P6 p6, P7 p7, P8 p8, P9 p9, P10 p10,
  1675.     P11 p11, P12 p12, P13 p13, P14 p14, P15 p15,
  1676.     P16 p16, P17 p17, P18 p18, P19 p19, P20 p20,
  1677.     P21 p21, P22 p22, P23 p23, P24 p24, P25 p25,
  1678.     P26 p26, P27 p27)
  1679.   {
  1680.     TAutoArgs<27> args;
  1681.     args[1] = p1;  args[2] = p2;  args[3] = p3;
  1682.     args[4] = p4;  args[5] = p5;  args[6] = p6;
  1683.     args[7] = p7;  args[8] = p8;  args[9] = p9;
  1684.     args[10] = p10;  args[11] = p11;  args[12] = p12;
  1685.     args[13] = p13;  args[14] = p14;  args[15] = p15;
  1686.     args[16] = p16;  args[17] = p17;  args[18] = p18;
  1687.     args[19] = p19;  args[20] = p20;  args[21] = p21;
  1688.     args[22] = p22;  args[23] = p23;  args[24] = p24;
  1689.     args[25] = p25;  args[26] = p26;  args[27] = p27;
  1690.     OleProcedure(name, static_cast<TAutoArgsBase*>(&args));
  1691.   }
  1692.  
  1693.   template <class P1, class P2, class P3, class P4, class P5,
  1694.             class P6, class P7, class P8, class P9, class P10,
  1695.             class P11, class P12, class P13, class P14, class P15,
  1696.             class P16, class P17, class P18, class P19, class P20,
  1697.             class P21, class P22, class P23, class P24, class P25,
  1698.             class P26, class P27, class P28>
  1699.   void Variant::OleProcedure(const String& name,
  1700.     P1 p1, P2 p2, P3 p3, P4 p4, P5 p5,
  1701.     P6 p6, P7 p7, P8 p8, P9 p9, P10 p10,
  1702.     P11 p11, P12 p12, P13 p13, P14 p14, P15 p15,
  1703.     P16 p16, P17 p17, P18 p18, P19 p19, P20 p20,
  1704.     P21 p21, P22 p22, P23 p23, P24 p24, P25 p25,
  1705.     P26 p26, P27 p27, P28 p28)
  1706.   {
  1707.     TAutoArgs<28> args;
  1708.     args[1] = p1;  args[2] = p2;  args[3] = p3;
  1709.     args[4] = p4;  args[5] = p5;  args[6] = p6;
  1710.     args[7] = p7;  args[8] = p8;  args[9] = p9;
  1711.     args[10] = p10;  args[11] = p11;  args[12] = p12;
  1712.     args[13] = p13;  args[14] = p14;  args[15] = p15;
  1713.     args[16] = p16;  args[17] = p17;  args[18] = p18;
  1714.     args[19] = p19;  args[20] = p20;  args[21] = p21;
  1715.     args[22] = p22;  args[23] = p23;  args[24] = p24;
  1716.     args[25] = p25;  args[26] = p26;  args[27] = p27;
  1717.     args[28] = p28;
  1718.     OleProcedure(name, static_cast<TAutoArgsBase*>(&args));
  1719.   }
  1720.  
  1721.   template <class P1, class P2, class P3, class P4, class P5,
  1722.             class P6, class P7, class P8, class P9, class P10,
  1723.             class P11, class P12, class P13, class P14, class P15,
  1724.             class P16, class P17, class P18, class P19, class P20,
  1725.             class P21, class P22, class P23, class P24, class P25,
  1726.             class P26, class P27, class P28, class P29>
  1727.   void Variant::OleProcedure(const String& name,
  1728.     P1 p1, P2 p2, P3 p3, P4 p4, P5 p5,
  1729.     P6 p6, P7 p7, P8 p8, P9 p9, P10 p10,
  1730.     P11 p11, P12 p12, P13 p13, P14 p14, P15 p15,
  1731.     P16 p16, P17 p17, P18 p18, P19 p19, P20 p20,
  1732.     P21 p21, P22 p22, P23 p23, P24 p24, P25 p25,
  1733.     P26 p26, P27 p27, P28 p28, P29 p29)
  1734.   {
  1735.     TAutoArgs<29> args;
  1736.     args[1] = p1;  args[2] = p2;  args[3] = p3;
  1737.     args[4] = p4;  args[5] = p5;  args[6] = p6;
  1738.     args[7] = p7;  args[8] = p8;  args[9] = p9;
  1739.     args[10] = p10;  args[11] = p11;  args[12] = p12;
  1740.     args[13] = p13;  args[14] = p14;  args[15] = p15;
  1741.     args[16] = p16;  args[17] = p17;  args[18] = p18;
  1742.     args[19] = p19;  args[20] = p20;  args[21] = p21;
  1743.     args[22] = p22;  args[23] = p23;  args[24] = p24;
  1744.     args[25] = p25;  args[26] = p26;  args[27] = p27;
  1745.     args[28] = p28;  args[29] = p29;
  1746.     OleProcedure(name, static_cast<TAutoArgsBase*>(&args));
  1747.   }
  1748.  
  1749.   template <class P1, class P2, class P3, class P4, class P5,
  1750.             class P6, class P7, class P8, class P9, class P10,
  1751.             class P11, class P12, class P13, class P14, class P15,
  1752.             class P16, class P17, class P18, class P19, class P20,
  1753.             class P21, class P22, class P23, class P24, class P25,
  1754.             class P26, class P27, class P28, class P29, class P30>
  1755.   void Variant::OleProcedure(const String& name,
  1756.     P1 p1, P2 p2, P3 p3, P4 p4, P5 p5,
  1757.     P6 p6, P7 p7, P8 p8, P9 p9, P10 p10,
  1758.     P11 p11, P12 p12, P13 p13, P14 p14, P15 p15,
  1759.     P16 p16, P17 p17, P18 p18, P19 p19, P20 p20,
  1760.     P21 p21, P22 p22, P23 p23, P24 p24, P25 p25,
  1761.     P26 p26, P27 p27, P28 p28, P29 p29, P30 p30)
  1762.   {
  1763.     TAutoArgs<30> args;
  1764.     args[1] = p1;  args[2] = p2;  args[3] = p3;
  1765.     args[4] = p4;  args[5] = p5;  args[6] = p6;
  1766.     args[7] = p7;  args[8] = p8;  args[9] = p9;
  1767.     args[10] = p10;  args[11] = p11;  args[12] = p12;
  1768.     args[13] = p13;  args[14] = p14;  args[15] = p15;
  1769.     args[16] = p16;  args[17] = p17;  args[18] = p18;
  1770.     args[19] = p19;  args[20] = p20;  args[21] = p21;
  1771.     args[22] = p22;  args[23] = p23;  args[24] = p24;
  1772.     args[25] = p25;  args[26] = p26;  args[27] = p27;
  1773.     args[28] = p28;  args[29] = p29;  args[30] = p30;
  1774.     OleProcedure(name, static_cast<TAutoArgsBase*>(&args));
  1775.   }
  1776.  
  1777.   template <class P1, class P2, class P3, class P4, class P5,
  1778.             class P6, class P7, class P8, class P9, class P10,
  1779.             class P11, class P12, class P13, class P14, class P15,
  1780.             class P16, class P17, class P18, class P19, class P20,
  1781.             class P21, class P22, class P23, class P24, class P25,
  1782.             class P26, class P27, class P28, class P29, class P30,
  1783.             class P31>
  1784.   void Variant::OleProcedure(const String& name,
  1785.     P1 p1, P2 p2, P3 p3, P4 p4, P5 p5,
  1786.     P6 p6, P7 p7, P8 p8, P9 p9, P10 p10,
  1787.     P11 p11, P12 p12, P13 p13, P14 p14, P15 p15,
  1788.     P16 p16, P17 p17, P18 p18, P19 p19, P20 p20,
  1789.     P21 p21, P22 p22, P23 p23, P24 p24, P25 p25,
  1790.     P26 p26, P27 p27, P28 p28, P29 p29, P30 p30,
  1791.     P31 p31)
  1792.   {
  1793.     TAutoArgs<31> args;
  1794.     args[1] = p1;  args[2] = p2;  args[3] = p3;
  1795.     args[4] = p4;  args[5] = p5;  args[6] = p6;
  1796.     args[7] = p7;  args[8] = p8;  args[9] = p9;
  1797.     args[10] = p10;  args[11] = p11;  args[12] = p12;
  1798.     args[13] = p13;  args[14] = p14;  args[15] = p15;
  1799.     args[16] = p16;  args[17] = p17;  args[18] = p18;
  1800.     args[19] = p19;  args[20] = p20;  args[21] = p21;
  1801.     args[22] = p22;  args[23] = p23;  args[24] = p24;
  1802.     args[25] = p25;  args[26] = p26;  args[27] = p27;
  1803.     args[28] = p28;  args[29] = p29;  args[30] = p30;
  1804.     args[31] = p31;
  1805.     OleProcedure(name, static_cast<TAutoArgsBase*>(&args));
  1806.   }
  1807.  
  1808.   template <class P1, class P2, class P3, class P4, class P5,
  1809.             class P6, class P7, class P8, class P9, class P10,
  1810.             class P11, class P12, class P13, class P14, class P15,
  1811.             class P16, class P17, class P18, class P19, class P20,
  1812.             class P21, class P22, class P23, class P24, class P25,
  1813.             class P26, class P27, class P28, class P29, class P30,
  1814.             class P31, class P32>
  1815.   void Variant::OleProcedure(const String& name,
  1816.     P1 p1, P2 p2, P3 p3, P4 p4, P5 p5,
  1817.     P6 p6, P7 p7, P8 p8, P9 p9, P10 p10,
  1818.     P11 p11, P12 p12, P13 p13, P14 p14, P15 p15,
  1819.     P16 p16, P17 p17, P18 p18, P19 p19, P20 p20,
  1820.     P21 p21, P22 p22, P23 p23, P24 p24, P25 p25,
  1821.     P26 p26, P27 p27, P28 p28, P29 p29, P30 p30,
  1822.     P31 p31, P32 p32)
  1823.   {
  1824.     TAutoArgs<32> args;
  1825.     args[1] = p1;  args[2] = p2;  args[3] = p3;
  1826.     args[4] = p4;  args[5] = p5;  args[6] = p6;
  1827.     args[7] = p7;  args[8] = p8;  args[9] = p9;
  1828.     args[10] = p10;  args[11] = p11;  args[12] = p12;
  1829.     args[13] = p13;  args[14] = p14;  args[15] = p15;
  1830.     args[16] = p16;  args[17] = p17;  args[18] = p18;
  1831.     args[19] = p19;  args[20] = p20;  args[21] = p21;
  1832.     args[22] = p22;  args[23] = p23;  args[24] = p24;
  1833.     args[25] = p25;  args[26] = p26;  args[27] = p27;
  1834.     args[28] = p28;  args[29] = p29;  args[30] = p30;
  1835.     args[31] = p31;  args[32] = p32;
  1836.     OleProcedure(name, static_cast<TAutoArgsBase*>(&args));
  1837.   }
  1838.  
  1839.   template <class P1>
  1840.   Variant Variant::OleFunction(const String& name, P1 p1)
  1841.   {
  1842.     TAutoArgs<1> args;
  1843.     args[1] = p1;
  1844.     return OleFunction(name, static_cast<TAutoArgsBase*>(&args));
  1845.   }
  1846.  
  1847.   template <class P1, class P2>
  1848.   Variant Variant::OleFunction(const String& name, P1 p1, P2 p2)
  1849.   {
  1850.     TAutoArgs<2> args;
  1851.     args[1] = p1;  args[2] = p2;
  1852.     return OleFunction(name, static_cast<TAutoArgsBase*>(&args));
  1853.   }
  1854.  
  1855.   template <class P1, class P2, class P3>
  1856.   Variant Variant::OleFunction(const String& name, P1 p1, P2 p2, P3 p3)
  1857.   {
  1858.     TAutoArgs<3> args;
  1859.     args[1] = p1;  args[2] = p2;  args[3] = p3;
  1860.     return OleFunction(name, static_cast<TAutoArgsBase*>(&args));
  1861.   }
  1862.  
  1863.   template <class P1, class P2, class P3, class P4>
  1864.   Variant Variant::OleFunction(const String& name, P1 p1, P2 p2, P3 p3, P4 p4)
  1865.   {
  1866.     TAutoArgs<4> args;
  1867.     args[1] = p1;  args[2] = p2;  args[3] = p3;
  1868.     args[4] = p4;
  1869.     return OleFunction(name, static_cast<TAutoArgsBase*>(&args));
  1870.   }
  1871.  
  1872.   template <class P1, class P2, class P3, class P4, class P5>
  1873.   Variant Variant::OleFunction(const String& name, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
  1874.   {
  1875.     TAutoArgs<5> args;
  1876.     args[1] = p1;  args[2] = p2;  args[3] = p3;
  1877.     args[4] = p4;  args[5] = p5;
  1878.     return OleFunction(name, static_cast<TAutoArgsBase*>(&args));
  1879.   }
  1880.  
  1881.   template <class P1, class P2, class P3, class P4, class P5,
  1882.             class P6>
  1883.   Variant Variant::OleFunction(const String& name,
  1884.     P1 p1, P2 p2, P3 p3, P4 p4, P5 p5,
  1885.     P6 p6)
  1886.   {
  1887.     TAutoArgs<6> args;
  1888.     args[1] = p1;  args[2] = p2;  args[3] = p3;
  1889.     args[4] = p4;  args[5] = p5;  args[6] = p6;
  1890.     return OleFunction(name, static_cast<TAutoArgsBase*>(&args));
  1891.   }
  1892.  
  1893.   template <class P1, class P2, class P3, class P4, class P5,
  1894.             class P6, class P7>
  1895.   Variant Variant::OleFunction(const String& name,
  1896.     P1 p1, P2 p2, P3 p3, P4 p4, P5 p5,
  1897.     P6 p6, P7 p7)
  1898.   {
  1899.     TAutoArgs<7> args;
  1900.     args[1] = p1;  args[2] = p2;  args[3] = p3;
  1901.     args[4] = p4;  args[5] = p5;  args[6] = p6;
  1902.     args[7] = p7;
  1903.     return OleFunction(name, static_cast<TAutoArgsBase*>(&args));
  1904.   }
  1905.  
  1906.   template <class P1, class P2, class P3, class P4, class P5,
  1907.             class P6, class P7, class P8>
  1908.   Variant Variant::OleFunction(const String& name,
  1909.     P1 p1, P2 p2, P3 p3, P4 p4, P5 p5,
  1910.     P6 p6, P7 p7, P8 p8)
  1911.   {
  1912.     TAutoArgs<8> args;
  1913.     args[1] = p1;  args[2] = p2;  args[3] = p3;
  1914.     args[4] = p4;  args[5] = p5;  args[6] = p6;
  1915.     args[7] = p7;  args[8] = p8;
  1916.     return OleFunction(name, static_cast<TAutoArgsBase*>(&args));
  1917.   }
  1918.  
  1919.   template <class P1, class P2, class P3, class P4, class P5,
  1920.             class P6, class P7, class P8, class P9>
  1921.   Variant Variant::OleFunction(const String& name,
  1922.     P1 p1, P2 p2, P3 p3, P4 p4, P5 p5,
  1923.     P6 p6, P7 p7, P8 p8, P9 p9)
  1924.   {
  1925.     TAutoArgs<9> args;
  1926.     args[1] = p1;  args[2] = p2;  args[3] = p3;
  1927.     args[4] = p4;  args[5] = p5;  args[6] = p6;
  1928.     args[7] = p7;  args[8] = p8;  args[9] = p9;
  1929.     return OleFunction(name, static_cast<TAutoArgsBase*>(&args));
  1930.   }
  1931.  
  1932.   template <class P1, class P2, class P3, class P4, class P5,
  1933.             class P6, class P7, class P8, class P9, class P10>
  1934.   Variant Variant::OleFunction(const String& name,
  1935.     P1 p1, P2 p2, P3 p3, P4 p4, P5 p5,
  1936.     P6 p6, P7 p7, P8 p8, P9 p9, P10 p10)
  1937.   {
  1938.     TAutoArgs<10> args;
  1939.     args[1] = p1;  args[2] = p2;  args[3] = p3;
  1940.     args[4] = p4;  args[5] = p5;  args[6] = p6;
  1941.     args[7] = p7;  args[8] = p8;  args[9] = p9;
  1942.     args[10] = p10;
  1943.     return OleFunction(name, static_cast<TAutoArgsBase*>(&args));
  1944.   }
  1945.  
  1946.   template <class P1, class P2, class P3, class P4, class P5,
  1947.             class P6, class P7, class P8, class P9, class P10,
  1948.             class P11>
  1949.   Variant Variant::OleFunction(const String& name,
  1950.     P1 p1, P2 p2, P3 p3, P4 p4, P5 p5,
  1951.     P6 p6, P7 p7, P8 p8, P9 p9, P10 p10,
  1952.     P11 p11)
  1953.   {
  1954.     TAutoArgs<11> args;
  1955.     args[1] = p1;  args[2] = p2;  args[3] = p3;
  1956.     args[4] = p4;  args[5] = p5;  args[6] = p6;
  1957.     args[7] = p7;  args[8] = p8;  args[9] = p9;
  1958.     args[10] = p10;  args[11] = p11;
  1959.     return OleFunction(name, static_cast<TAutoArgsBase*>(&args));
  1960.   }
  1961.  
  1962.   template <class P1, class P2, class P3, class P4, class P5,
  1963.             class P6, class P7, class P8, class P9, class P10,
  1964.             class P11, class P12>
  1965.   Variant Variant::OleFunction(const String& name,
  1966.     P1 p1, P2 p2, P3 p3, P4 p4, P5 p5,
  1967.     P6 p6, P7 p7, P8 p8, P9 p9, P10 p10,
  1968.     P11 p11, P12 p12)
  1969.   {
  1970.     TAutoArgs<12> args;
  1971.     args[1] = p1;  args[2] = p2;  args[3] = p3;
  1972.     args[4] = p4;  args[5] = p5;  args[6] = p6;
  1973.     args[7] = p7;  args[8] = p8;  args[9] = p9;
  1974.     args[10] = p10;  args[11] = p11;  args[12] = p12;
  1975.     return OleFunction(name, static_cast<TAutoArgsBase*>(&args));
  1976.   }
  1977.  
  1978.   template <class P1, class P2, class P3, class P4, class P5,
  1979.             class P6, class P7, class P8, class P9, class P10,
  1980.             class P11, class P12, class P13>
  1981.   Variant Variant::OleFunction(const String& name,
  1982.     P1 p1, P2 p2, P3 p3, P4 p4, P5 p5,
  1983.     P6 p6, P7 p7, P8 p8, P9 p9, P10 p10,
  1984.     P11 p11, P12 p12, P13 p13)
  1985.   {
  1986.     TAutoArgs<13> args;
  1987.     args[1] = p1;  args[2] = p2;  args[3] = p3;
  1988.     args[4] = p4;  args[5] = p5;  args[6] = p6;
  1989.     args[7] = p7;  args[8] = p8;  args[9] = p9;
  1990.     args[10] = p10;  args[11] = p11;  args[12] = p12;
  1991.     args[13] = p13;
  1992.     return OleFunction(name, static_cast<TAutoArgsBase*>(&args));
  1993.   }
  1994.  
  1995.   template <class P1, class P2, class P3, class P4, class P5,
  1996.             class P6, class P7, class P8, class P9, class P10,
  1997.             class P11, class P12, class P13, class P14>
  1998.   Variant Variant::OleFunction(const String& name,
  1999.     P1 p1, P2 p2, P3 p3, P4 p4, P5 p5,
  2000.     P6 p6, P7 p7, P8 p8, P9 p9, P10 p10,
  2001.     P11 p11, P12 p12, P13 p13, P14 p14)
  2002.   {
  2003.     TAutoArgs<14> args;
  2004.     args[1] = p1;  args[2] = p2;  args[3] = p3;
  2005.     args[4] = p4;  args[5] = p5;  args[6] = p6;
  2006.     args[7] = p7;  args[8] = p8;  args[9] = p9;
  2007.     args[10] = p10;  args[11] = p11;  args[12] = p12;
  2008.     args[13] = p13;  args[14] = p14;
  2009.     return OleFunction(name, static_cast<TAutoArgsBase*>(&args));
  2010.   }
  2011.  
  2012.   template <class P1, class P2, class P3, class P4, class P5,
  2013.             class P6, class P7, class P8, class P9, class P10,
  2014.             class P11, class P12, class P13, class P14, class P15>
  2015.   Variant Variant::OleFunction(const String& name,
  2016.     P1 p1, P2 p2, P3 p3, P4 p4, P5 p5,
  2017.     P6 p6, P7 p7, P8 p8, P9 p9, P10 p10,
  2018.     P11 p11, P12 p12, P13 p13, P14 p14, P15 p15)
  2019.   {
  2020.     TAutoArgs<15> args;
  2021.     args[1] = p1;  args[2] = p2;  args[3] = p3;
  2022.     args[4] = p4;  args[5] = p5;  args[6] = p6;
  2023.     args[7] = p7;  args[8] = p8;  args[9] = p9;
  2024.     args[10] = p10;  args[11] = p11;  args[12] = p12;
  2025.     args[13] = p13;  args[14] = p14;  args[15] = p15;
  2026.     return OleFunction(name, static_cast<TAutoArgsBase*>(&args));
  2027.   }
  2028.  
  2029.   template <class P1, class P2, class P3, class P4, class P5,
  2030.             class P6, class P7, class P8, class P9, class P10,
  2031.             class P11, class P12, class P13, class P14, class P15,
  2032.             class P16>
  2033.   Variant Variant::OleFunction(const String& name,
  2034.     P1 p1, P2 p2, P3 p3, P4 p4, P5 p5,
  2035.     P6 p6, P7 p7, P8 p8, P9 p9, P10 p10,
  2036.     P11 p11, P12 p12, P13 p13, P14 p14, P15 p15,
  2037.     P16 p16)
  2038.   {
  2039.     TAutoArgs<16> args;
  2040.     args[1] = p1;  args[2] = p2;  args[3] = p3;
  2041.     args[4] = p4;  args[5] = p5;  args[6] = p6;
  2042.     args[7] = p7;  args[8] = p8;  args[9] = p9;
  2043.     args[10] = p10;  args[11] = p11;  args[12] = p12;
  2044.     args[13] = p13;  args[14] = p14;  args[15] = p15;
  2045.     args[16] = p16;
  2046.     return OleFunction(name, static_cast<TAutoArgsBase*>(&args));
  2047.   }
  2048.  
  2049.   template <class P1, class P2, class P3, class P4, class P5,
  2050.             class P6, class P7, class P8, class P9, class P10,
  2051.             class P11, class P12, class P13, class P14, class P15,
  2052.             class P16, class P17>
  2053.   Variant Variant::OleFunction(const String& name,
  2054.     P1 p1, P2 p2, P3 p3, P4 p4, P5 p5,
  2055.     P6 p6, P7 p7, P8 p8, P9 p9, P10 p10,
  2056.     P11 p11, P12 p12, P13 p13, P14 p14, P15 p15,
  2057.     P16 p16, P17 p17)
  2058.   {
  2059.     TAutoArgs<17> args;
  2060.     args[1] = p1;  args[2] = p2;  args[3] = p3;
  2061.     args[4] = p4;  args[5] = p5;  args[6] = p6;
  2062.     args[7] = p7;  args[8] = p8;  args[9] = p9;
  2063.     args[10] = p10;  args[11] = p11;  args[12] = p12;
  2064.     args[13] = p13;  args[14] = p14;  args[15] = p15;
  2065.     args[16] = p16;  args[17] = p17;
  2066.     return OleFunction(name, static_cast<TAutoArgsBase*>(&args));
  2067.   }
  2068.  
  2069.   template <class P1, class P2, class P3, class P4, class P5,
  2070.             class P6, class P7, class P8, class P9, class P10,
  2071.             class P11, class P12, class P13, class P14, class P15,
  2072.             class P16, class P17, class P18>
  2073.   Variant Variant::OleFunction(const String& name,
  2074.     P1 p1, P2 p2, P3 p3, P4 p4, P5 p5,
  2075.     P6 p6, P7 p7, P8 p8, P9 p9, P10 p10,
  2076.     P11 p11, P12 p12, P13 p13, P14 p14, P15 p15,
  2077.     P16 p16, P17 p17, P18 p18)
  2078.   {
  2079.     TAutoArgs<18> args;
  2080.     args[1] = p1;  args[2] = p2;  args[3] = p3;
  2081.     args[4] = p4;  args[5] = p5;  args[6] = p6;
  2082.     args[7] = p7;  args[8] = p8;  args[9] = p9;
  2083.     args[10] = p10;  args[11] = p11;  args[12] = p12;
  2084.     args[13] = p13;  args[14] = p14;  args[15] = p15;
  2085.     args[16] = p16;  args[17] = p17;  args[18] = p18;
  2086.     return OleFunction(name, static_cast<TAutoArgsBase*>(&args));
  2087.   }
  2088.  
  2089.   template <class P1, class P2, class P3, class P4, class P5,
  2090.             class P6, class P7, class P8, class P9, class P10,
  2091.             class P11, class P12, class P13, class P14, class P15,
  2092.             class P16, class P17, class P18, class P19>
  2093.   Variant Variant::OleFunction(const String& name,
  2094.     P1 p1, P2 p2, P3 p3, P4 p4, P5 p5,
  2095.     P6 p6, P7 p7, P8 p8, P9 p9, P10 p10,
  2096.     P11 p11, P12 p12, P13 p13, P14 p14, P15 p15,
  2097.     P16 p16, P17 p17, P18 p18, P19 p19)
  2098.   {
  2099.     TAutoArgs<19> args;
  2100.     args[1] = p1;  args[2] = p2;  args[3] = p3;
  2101.     args[4] = p4;  args[5] = p5;  args[6] = p6;
  2102.     args[7] = p7;  args[8] = p8;  args[9] = p9;
  2103.     args[10] = p10;  args[11] = p11;  args[12] = p12;
  2104.     args[13] = p13;  args[14] = p14;  args[15] = p15;
  2105.     args[16] = p16;  args[17] = p17;  args[18] = p18;
  2106.     args[19] = p19;
  2107.     return OleFunction(name, static_cast<TAutoArgsBase*>(&args));
  2108.   }
  2109.  
  2110.   template <class P1, class P2, class P3, class P4, class P5,
  2111.             class P6, class P7, class P8, class P9, class P10,
  2112.             class P11, class P12, class P13, class P14, class P15,
  2113.             class P16, class P17, class P18, class P19, class P20>
  2114.   Variant Variant::OleFunction(const String& name,
  2115.     P1 p1, P2 p2, P3 p3, P4 p4, P5 p5,
  2116.     P6 p6, P7 p7, P8 p8, P9 p9, P10 p10,
  2117.     P11 p11, P12 p12, P13 p13, P14 p14, P15 p15,
  2118.     P16 p16, P17 p17, P18 p18, P19 p19, P20 p20)
  2119.   {
  2120.     TAutoArgs<20> args;
  2121.     args[1] = p1;  args[2] = p2;  args[3] = p3;
  2122.     args[4] = p4;  args[5] = p5;  args[6] = p6;
  2123.     args[7] = p7;  args[8] = p8;  args[9] = p9;
  2124.     args[10] = p10;  args[11] = p11;  args[12] = p12;
  2125.     args[13] = p13;  args[14] = p14;  args[15] = p15;
  2126.     args[16] = p16;  args[17] = p17;  args[18] = p18;
  2127.     args[19] = p19;  args[20] = p20;
  2128.     return OleFunction(name, static_cast<TAutoArgsBase*>(&args));
  2129.   }
  2130.  
  2131.   template <class P1, class P2, class P3, class P4, class P5,
  2132.             class P6, class P7, class P8, class P9, class P10,
  2133.             class P11, class P12, class P13, class P14, class P15,
  2134.             class P16, class P17, class P18, class P19, class P20,
  2135.             class P21>
  2136.   Variant Variant::OleFunction(const String& name,
  2137.     P1 p1, P2 p2, P3 p3, P4 p4, P5 p5,
  2138.     P6 p6, P7 p7, P8 p8, P9 p9, P10 p10,
  2139.     P11 p11, P12 p12, P13 p13, P14 p14, P15 p15,
  2140.     P16 p16, P17 p17, P18 p18, P19 p19, P20 p20,
  2141.     P21 p21)
  2142.   {
  2143.     TAutoArgs<21> args;
  2144.     args[1] = p1;  args[2] = p2;  args[3] = p3;
  2145.     args[4] = p4;  args[5] = p5;  args[6] = p6;
  2146.     args[7] = p7;  args[8] = p8;  args[9] = p9;
  2147.     args[10] = p10;  args[11] = p11;  args[12] = p12;
  2148.     args[13] = p13;  args[14] = p14;  args[15] = p15;
  2149.     args[16] = p16;  args[17] = p17;  args[18] = p18;
  2150.     args[19] = p19;  args[20] = p20;  args[21] = p21;
  2151.     return OleFunction(name, static_cast<TAutoArgsBase*>(&args));
  2152.   }
  2153.  
  2154.   template <class P1, class P2, class P3, class P4, class P5,
  2155.             class P6, class P7, class P8, class P9, class P10,
  2156.             class P11, class P12, class P13, class P14, class P15,
  2157.             class P16, class P17, class P18, class P19, class P20,
  2158.             class P21, class P22>
  2159.   Variant Variant::OleFunction(const String& name,
  2160.     P1 p1, P2 p2, P3 p3, P4 p4, P5 p5,
  2161.     P6 p6, P7 p7, P8 p8, P9 p9, P10 p10,
  2162.     P11 p11, P12 p12, P13 p13, P14 p14, P15 p15,
  2163.     P16 p16, P17 p17, P18 p18, P19 p19, P20 p20,
  2164.     P21 p21, P22 p22)
  2165.   {
  2166.     TAutoArgs<22> args;
  2167.     args[1] = p1;  args[2] = p2;  args[3] = p3;
  2168.     args[4] = p4;  args[5] = p5;  args[6] = p6;
  2169.     args[7] = p7;  args[8] = p8;  args[9] = p9;
  2170.     args[10] = p10;  args[11] = p11;  args[12] = p12;
  2171.     args[13] = p13;  args[14] = p14;  args[15] = p15;
  2172.     args[16] = p16;  args[17] = p17;  args[18] = p18;
  2173.     args[19] = p19;  args[20] = p20;  args[21] = p21;
  2174.     args[22] = p22;
  2175.     return OleFunction(name, static_cast<TAutoArgsBase*>(&args));
  2176.   }
  2177.  
  2178.   template <class P1, class P2, class P3, class P4, class P5,
  2179.             class P6, class P7, class P8, class P9, class P10,
  2180.             class P11, class P12, class P13, class P14, class P15,
  2181.             class P16, class P17, class P18, class P19, class P20,
  2182.             class P21, class P22, class P23>
  2183.   Variant Variant::OleFunction(const String& name,
  2184.     P1 p1, P2 p2, P3 p3, P4 p4, P5 p5,
  2185.     P6 p6, P7 p7, P8 p8, P9 p9, P10 p10,
  2186.     P11 p11, P12 p12, P13 p13, P14 p14, P15 p15,
  2187.     P16 p16, P17 p17, P18 p18, P19 p19, P20 p20,
  2188.     P21 p21, P22 p22, P23 p23)
  2189.   {
  2190.     TAutoArgs<23> args;
  2191.     args[1] = p1;  args[2] = p2;  args[3] = p3;
  2192.     args[4] = p4;  args[5] = p5;  args[6] = p6;
  2193.     args[7] = p7;  args[8] = p8;  args[9] = p9;
  2194.     args[10] = p10;  args[11] = p11;  args[12] = p12;
  2195.     args[13] = p13;  args[14] = p14;  args[15] = p15;
  2196.     args[16] = p16;  args[17] = p17;  args[18] = p18;
  2197.     args[19] = p19;  args[20] = p20;  args[21] = p21;
  2198.     args[22] = p22;  args[23] = p23;
  2199.     return OleFunction(name, static_cast<TAutoArgsBase*>(&args));
  2200.   }
  2201.  
  2202.   template <class P1, class P2, class P3, class P4, class P5,
  2203.             class P6, class P7, class P8, class P9, class P10,
  2204.             class P11, class P12, class P13, class P14, class P15,
  2205.             class P16, class P17, class P18, class P19, class P20,
  2206.             class P21, class P22, class P23, class P24>
  2207.   Variant Variant::OleFunction(const String& name,
  2208.     P1 p1, P2 p2, P3 p3, P4 p4, P5 p5,
  2209.     P6 p6, P7 p7, P8 p8, P9 p9, P10 p10,
  2210.     P11 p11, P12 p12, P13 p13, P14 p14, P15 p15,
  2211.     P16 p16, P17 p17, P18 p18, P19 p19, P20 p20,
  2212.     P21 p21, P22 p22, P23 p23, P24 p24)
  2213.   {
  2214.     TAutoArgs<24> args;
  2215.     args[1] = p1;  args[2] = p2;  args[3] = p3;
  2216.     args[4] = p4;  args[5] = p5;  args[6] = p6;
  2217.     args[7] = p7;  args[8] = p8;  args[9] = p9;
  2218.     args[10] = p10;  args[11] = p11;  args[12] = p12;
  2219.     args[13] = p13;  args[14] = p14;  args[15] = p15;
  2220.     args[16] = p16;  args[17] = p17;  args[18] = p18;
  2221.     args[19] = p19;  args[20] = p20;  args[21] = p21;
  2222.     args[22] = p22;  args[23] = p23;  args[24] = p24;
  2223.     return OleFunction(name, static_cast<TAutoArgsBase*>(&args));
  2224.   }
  2225.  
  2226.   template <class P1, class P2, class P3, class P4, class P5,
  2227.             class P6, class P7, class P8, class P9, class P10,
  2228.             class P11, class P12, class P13, class P14, class P15,
  2229.             class P16, class P17, class P18, class P19, class P20,
  2230.             class P21, class P22, class P23, class P24, class P25>
  2231.   Variant Variant::OleFunction(const String& name,
  2232.     P1 p1, P2 p2, P3 p3, P4 p4, P5 p5,
  2233.     P6 p6, P7 p7, P8 p8, P9 p9, P10 p10,
  2234.     P11 p11, P12 p12, P13 p13, P14 p14, P15 p15,
  2235.     P16 p16, P17 p17, P18 p18, P19 p19, P20 p20,
  2236.     P21 p21, P22 p22, P23 p23, P24 p24, P25 p25)
  2237.   {
  2238.     TAutoArgs<25> args;
  2239.     args[1] = p1;  args[2] = p2;  args[3] = p3;
  2240.     args[4] = p4;  args[5] = p5;  args[6] = p6;
  2241.     args[7] = p7;  args[8] = p8;  args[9] = p9;
  2242.     args[10] = p10;  args[11] = p11;  args[12] = p12;
  2243.     args[13] = p13;  args[14] = p14;  args[15] = p15;
  2244.     args[16] = p16;  args[17] = p17;  args[18] = p18;
  2245.     args[19] = p19;  args[20] = p20;  args[21] = p21;
  2246.     args[22] = p22;  args[23] = p23;  args[24] = p24;
  2247.     args[25] = p25;
  2248.     return OleFunction(name, static_cast<TAutoArgsBase*>(&args));
  2249.   }
  2250.  
  2251.   template <class P1, class P2, class P3, class P4, class P5,
  2252.             class P6, class P7, class P8, class P9, class P10,
  2253.             class P11, class P12, class P13, class P14, class P15,
  2254.             class P16, class P17, class P18, class P19, class P20,
  2255.             class P21, class P22, class P23, class P24, class P25,
  2256.             class P26>
  2257.   Variant Variant::OleFunction(const String& name,
  2258.     P1 p1, P2 p2, P3 p3, P4 p4, P5 p5,
  2259.     P6 p6, P7 p7, P8 p8, P9 p9, P10 p10,
  2260.     P11 p11, P12 p12, P13 p13, P14 p14, P15 p15,
  2261.     P16 p16, P17 p17, P18 p18, P19 p19, P20 p20,
  2262.     P21 p21, P22 p22, P23 p23, P24 p24, P25 p25,
  2263.     P26 p26)
  2264.   {
  2265.     TAutoArgs<26> args;
  2266.     args[1] = p1;  args[2] = p2;  args[3] = p3;
  2267.     args[4] = p4;  args[5] = p5;  args[6] = p6;
  2268.     args[7] = p7;  args[8] = p8;  args[9] = p9;
  2269.     args[10] = p10;  args[11] = p11;  args[12] = p12;
  2270.     args[13] = p13;  args[14] = p14;  args[15] = p15;
  2271.     args[16] = p16;  args[17] = p17;  args[18] = p18;
  2272.     args[19] = p19;  args[20] = p20;  args[21] = p21;
  2273.     args[22] = p22;  args[23] = p23;  args[24] = p24;
  2274.     args[25] = p25;  args[26] = p26;
  2275.     return OleFunction(name, static_cast<TAutoArgsBase*>(&args));
  2276.   }
  2277.  
  2278.   template <class P1, class P2, class P3, class P4, class P5,
  2279.             class P6, class P7, class P8, class P9, class P10,
  2280.             class P11, class P12, class P13, class P14, class P15,
  2281.             class P16, class P17, class P18, class P19, class P20,
  2282.             class P21, class P22, class P23, class P24, class P25,
  2283.             class P26, class P27>
  2284.   Variant Variant::OleFunction(const String& name,
  2285.     P1 p1, P2 p2, P3 p3, P4 p4, P5 p5,
  2286.     P6 p6, P7 p7, P8 p8, P9 p9, P10 p10,
  2287.     P11 p11, P12 p12, P13 p13, P14 p14, P15 p15,
  2288.     P16 p16, P17 p17, P18 p18, P19 p19, P20 p20,
  2289.     P21 p21, P22 p22, P23 p23, P24 p24, P25 p25,
  2290.     P26 p26, P27 p27)
  2291.   {
  2292.     TAutoArgs<27> args;
  2293.     args[1] = p1;  args[2] = p2;  args[3] = p3;
  2294.     args[4] = p4;  args[5] = p5;  args[6] = p6;
  2295.     args[7] = p7;  args[8] = p8;  args[9] = p9;
  2296.     args[10] = p10;  args[11] = p11;  args[12] = p12;
  2297.     args[13] = p13;  args[14] = p14;  args[15] = p15;
  2298.     args[16] = p16;  args[17] = p17;  args[18] = p18;
  2299.     args[19] = p19;  args[20] = p20;  args[21] = p21;
  2300.     args[22] = p22;  args[23] = p23;  args[24] = p24;
  2301.     args[25] = p25;  args[26] = p26;  args[27] = p27;
  2302.     return OleFunction(name, static_cast<TAutoArgsBase*>(&args));
  2303.   }
  2304.  
  2305.   template <class P1, class P2, class P3, class P4, class P5,
  2306.             class P6, class P7, class P8, class P9, class P10,
  2307.             class P11, class P12, class P13, class P14, class P15,
  2308.             class P16, class P17, class P18, class P19, class P20,
  2309.             class P21, class P22, class P23, class P24, class P25,
  2310.             class P26, class P27, class P28>
  2311.   Variant Variant::OleFunction(const String& name,
  2312.     P1 p1, P2 p2, P3 p3, P4 p4, P5 p5,
  2313.     P6 p6, P7 p7, P8 p8, P9 p9, P10 p10,
  2314.     P11 p11, P12 p12, P13 p13, P14 p14, P15 p15,
  2315.     P16 p16, P17 p17, P18 p18, P19 p19, P20 p20,
  2316.     P21 p21, P22 p22, P23 p23, P24 p24, P25 p25,
  2317.     P26 p26, P27 p27, P28 p28)
  2318.   {
  2319.     TAutoArgs<28> args;
  2320.     args[1] = p1;  args[2] = p2;  args[3] = p3;
  2321.     args[4] = p4;  args[5] = p5;  args[6] = p6;
  2322.     args[7] = p7;  args[8] = p8;  args[9] = p9;
  2323.     args[10] = p10;  args[11] = p11;  args[12] = p12;
  2324.     args[13] = p13;  args[14] = p14;  args[15] = p15;
  2325.     args[16] = p16;  args[17] = p17;  args[18] = p18;
  2326.     args[19] = p19;  args[20] = p20;  args[21] = p21;
  2327.     args[22] = p22;  args[23] = p23;  args[24] = p24;
  2328.     args[25] = p25;  args[26] = p26;  args[27] = p27;
  2329.     args[28] = p28;
  2330.     return OleFunction(name, static_cast<TAutoArgsBase*>(&args));
  2331.   }
  2332.  
  2333.   template <class P1, class P2, class P3, class P4, class P5,
  2334.             class P6, class P7, class P8, class P9, class P10,
  2335.             class P11, class P12, class P13, class P14, class P15,
  2336.             class P16, class P17, class P18, class P19, class P20,
  2337.             class P21, class P22, class P23, class P24, class P25,
  2338.             class P26, class P27, class P28, class P29>
  2339.   Variant Variant::OleFunction(const String& name,
  2340.     P1 p1, P2 p2, P3 p3, P4 p4, P5 p5,
  2341.     P6 p6, P7 p7, P8 p8, P9 p9, P10 p10,
  2342.     P11 p11, P12 p12, P13 p13, P14 p14, P15 p15,
  2343.     P16 p16, P17 p17, P18 p18, P19 p19, P20 p20,
  2344.     P21 p21, P22 p22, P23 p23, P24 p24, P25 p25,
  2345.     P26 p26, P27 p27, P28 p28, P29 p29)
  2346.   {
  2347.     TAutoArgs<29> args;
  2348.     args[1] = p1;  args[2] = p2;  args[3] = p3;
  2349.     args[4] = p4;  args[5] = p5;  args[6] = p6;
  2350.     args[7] = p7;  args[8] = p8;  args[9] = p9;
  2351.     args[10] = p10;  args[11] = p11;  args[12] = p12;
  2352.     args[13] = p13;  args[14] = p14;  args[15] = p15;
  2353.     args[16] = p16;  args[17] = p17;  args[18] = p18;
  2354.     args[19] = p19;  args[20] = p20;  args[21] = p21;
  2355.     args[22] = p22;  args[23] = p23;  args[24] = p24;
  2356.     args[25] = p25;  args[26] = p26;  args[27] = p27;
  2357.     args[28] = p28;  args[29] = p29;
  2358.     return OleFunction(name, static_cast<TAutoArgsBase*>(&args));
  2359.   }
  2360.  
  2361.   template <class P1, class P2, class P3, class P4, class P5,
  2362.             class P6, class P7, class P8, class P9, class P10,
  2363.             class P11, class P12, class P13, class P14, class P15,
  2364.             class P16, class P17, class P18, class P19, class P20,
  2365.             class P21, class P22, class P23, class P24, class P25,
  2366.             class P26, class P27, class P28, class P29, class P30>
  2367.   Variant Variant::OleFunction(const String& name,
  2368.     P1 p1, P2 p2, P3 p3, P4 p4, P5 p5,
  2369.     P6 p6, P7 p7, P8 p8, P9 p9, P10 p10,
  2370.     P11 p11, P12 p12, P13 p13, P14 p14, P15 p15,
  2371.     P16 p16, P17 p17, P18 p18, P19 p19, P20 p20,
  2372.     P21 p21, P22 p22, P23 p23, P24 p24, P25 p25,
  2373.     P26 p26, P27 p27, P28 p28, P29 p29, P30 p30)
  2374.   {
  2375.     TAutoArgs<30> args;
  2376.     args[1] = p1;  args[2] = p2;  args[3] = p3;
  2377.     args[4] = p4;  args[5] = p5;  args[6] = p6;
  2378.     args[7] = p7;  args[8] = p8;  args[9] = p9;
  2379.     args[10] = p10;  args[11] = p11;  args[12] = p12;
  2380.     args[13] = p13;  args[14] = p14;  args[15] = p15;
  2381.     args[16] = p16;  args[17] = p17;  args[18] = p18;
  2382.     args[19] = p19;  args[20] = p20;  args[21] = p21;
  2383.     args[22] = p22;  args[23] = p23;  args[24] = p24;
  2384.     args[25] = p25;  args[26] = p26;  args[27] = p27;
  2385.     args[28] = p28;  args[29] = p29;  args[30] = p30;
  2386.     return OleFunction(name, static_cast<TAutoArgsBase*>(&args));
  2387.   }
  2388.  
  2389.   template <class P1, class P2, class P3, class P4, class P5,
  2390.             class P6, class P7, class P8, class P9, class P10,
  2391.             class P11, class P12, class P13, class P14, class P15,
  2392.             class P16, class P17, class P18, class P19, class P20,
  2393.             class P21, class P22, class P23, class P24, class P25,
  2394.             class P26, class P27, class P28, class P29, class P30,
  2395.             class P31>
  2396.   Variant Variant::OleFunction(const String& name,
  2397.     P1 p1, P2 p2, P3 p3, P4 p4, P5 p5,
  2398.     P6 p6, P7 p7, P8 p8, P9 p9, P10 p10,
  2399.     P11 p11, P12 p12, P13 p13, P14 p14, P15 p15,
  2400.     P16 p16, P17 p17, P18 p18, P19 p19, P20 p20,
  2401.     P21 p21, P22 p22, P23 p23, P24 p24, P25 p25,
  2402.     P26 p26, P27 p27, P28 p28, P29 p29, P30 p30,
  2403.     P31 p31)
  2404.   {
  2405.     TAutoArgs<31> args;
  2406.     args[1] = p1;  args[2] = p2;  args[3] = p3;
  2407.     args[4] = p4;  args[5] = p5;  args[6] = p6;
  2408.     args[7] = p7;  args[8] = p8;  args[9] = p9;
  2409.     args[10] = p10;  args[11] = p11;  args[12] = p12;
  2410.     args[13] = p13;  args[14] = p14;  args[15] = p15;
  2411.     args[16] = p16;  args[17] = p17;  args[18] = p18;
  2412.     args[19] = p19;  args[20] = p20;  args[21] = p21;
  2413.     args[22] = p22;  args[23] = p23;  args[24] = p24;
  2414.     args[25] = p25;  args[26] = p26;  args[27] = p27;
  2415.     args[28] = p28;  args[29] = p29;  args[30] = p30;
  2416.     args[31] = p31;
  2417.     return OleFunction(name, static_cast<TAutoArgsBase*>(&args));
  2418.   }
  2419.  
  2420.   template <class P1, class P2, class P3, class P4, class P5,
  2421.             class P6, class P7, class P8, class P9, class P10,
  2422.             class P11, class P12, class P13, class P14, class P15,
  2423.             class P16, class P17, class P18, class P19, class P20,
  2424.             class P21, class P22, class P23, class P24, class P25,
  2425.             class P26, class P27, class P28, class P29, class P30,
  2426.             class P31, class P32>
  2427.   Variant Variant::OleFunction(const String& name,
  2428.     P1 p1, P2 p2, P3 p3, P4 p4, P5 p5,
  2429.     P6 p6, P7 p7, P8 p8, P9 p9, P10 p10,
  2430.     P11 p11, P12 p12, P13 p13, P14 p14, P15 p15,
  2431.     P16 p16, P17 p17, P18 p18, P19 p19, P20 p20,
  2432.     P21 p21, P22 p22, P23 p23, P24 p24, P25 p25,
  2433.     P26 p26, P27 p27, P28 p28, P29 p29, P30 p30,
  2434.     P31 p31, P32 p32)
  2435.   {
  2436.     TAutoArgs<32> args;
  2437.     args[1] = p1;  args[2] = p2;  args[3] = p3;
  2438.     args[4] = p4;  args[5] = p5;  args[6] = p6;
  2439.     args[7] = p7;  args[8] = p8;  args[9] = p9;
  2440.     args[10] = p10;  args[11] = p11;  args[12] = p12;
  2441.     args[13] = p13;  args[14] = p14;  args[15] = p15;
  2442.     args[16] = p16;  args[17] = p17;  args[18] = p18;
  2443.     args[19] = p19;  args[20] = p20;  args[21] = p21;
  2444.     args[22] = p22;  args[23] = p23;  args[24] = p24;
  2445.     args[25] = p25;  args[26] = p26;  args[27] = p27;
  2446.     args[28] = p28;  args[29] = p29;  args[30] = p30;
  2447.     args[31] = p31;  args[32] = p32;
  2448.     return OleFunction(name, static_cast<TAutoArgsBase*>(&args));
  2449.   }
  2450.  
  2451.   template <class P1>
  2452.   Variant Variant::OlePropertyGet(const String& name, P1 p1)
  2453.   {
  2454.     TAutoArgs<1> args;
  2455.     args[1] = p1;
  2456.     return OlePropertyGet(name, static_cast<TAutoArgsBase*>(&args));
  2457.   }
  2458.  
  2459.   template <class P1, class P2>
  2460.   Variant Variant::OlePropertyGet(const String& name, P1 p1, P2 p2)
  2461.   {
  2462.     TAutoArgs<2> args;
  2463.     args[1] = p1;  args[2] = p2;
  2464.     return OlePropertyGet(name, static_cast<TAutoArgsBase*>(&args));
  2465.   }
  2466.  
  2467.   template <class P1, class P2, class P3>
  2468.   Variant Variant::OlePropertyGet(const String& name, P1 p1, P2 p2, P3 p3)
  2469.   {
  2470.     TAutoArgs<3> args;
  2471.     args[1] = p1;  args[2] = p2;  args[3] = p3;
  2472.     return OlePropertyGet(name, static_cast<TAutoArgsBase*>(&args));
  2473.   }
  2474.  
  2475.   template <class P1, class P2, class P3, class P4>
  2476.   Variant Variant::OlePropertyGet(const String& name, P1 p1, P2 p2, P3 p3, P4 p4)
  2477.   {
  2478.     TAutoArgs<4> args;
  2479.     args[1] = p1;  args[2] = p2;  args[3] = p3;
  2480.     args[4] = p4;
  2481.     return OlePropertyGet(name, static_cast<TAutoArgsBase*>(&args));
  2482.   }
  2483.  
  2484.   template <class P1, class P2, class P3, class P4, class P5>
  2485.   Variant Variant::OlePropertyGet(const String& name, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
  2486.   {
  2487.     TAutoArgs<5> args;
  2488.     args[1] = p1;  args[2] = p2;  args[3] = p3;
  2489.     args[4] = p4;  args[5] = p5;
  2490.     return OlePropertyGet(name, static_cast<TAutoArgsBase*>(&args));
  2491.   }
  2492.  
  2493.   template <class P1, class P2, class P3, class P4, class P5,
  2494.             class P6>
  2495.   Variant Variant::OlePropertyGet(const String& name,
  2496.     P1 p1, P2 p2, P3 p3, P4 p4, P5 p5,
  2497.     P6 p6)
  2498.   {
  2499.     TAutoArgs<6> args;
  2500.     args[1] = p1;  args[2] = p2;  args[3] = p3;
  2501.     args[4] = p4;  args[5] = p5;  args[6] = p6;
  2502.     return OlePropertyGet(name, static_cast<TAutoArgsBase*>(&args));
  2503.   }
  2504.  
  2505.   template <class P1, class P2, class P3, class P4, class P5,
  2506.             class P6, class P7>
  2507.   Variant Variant::OlePropertyGet(const String& name,
  2508.     P1 p1, P2 p2, P3 p3, P4 p4, P5 p5,
  2509.     P6 p6, P7 p7)
  2510.   {
  2511.     TAutoArgs<7> args;
  2512.     args[1] = p1;  args[2] = p2;  args[3] = p3;
  2513.     args[4] = p4;  args[5] = p5;  args[6] = p6;
  2514.     args[7] = p7;
  2515.     return OlePropertyGet(name, static_cast<TAutoArgsBase*>(&args));
  2516.   }
  2517.  
  2518.   template <class P1, class P2, class P3, class P4, class P5,
  2519.             class P6, class P7, class P8>
  2520.   Variant Variant::OlePropertyGet(const String& name,
  2521.     P1 p1, P2 p2, P3 p3, P4 p4, P5 p5,
  2522.     P6 p6, P7 p7, P8 p8)
  2523.   {
  2524.     TAutoArgs<8> args;
  2525.     args[1] = p1;  args[2] = p2;  args[3] = p3;
  2526.     args[4] = p4;  args[5] = p5;  args[6] = p6;
  2527.     args[7] = p7;  args[8] = p8;
  2528.     return OlePropertyGet(name, static_cast<TAutoArgsBase*>(&args));
  2529.   }
  2530.  
  2531.   template <class P1, class P2, class P3, class P4, class P5,
  2532.             class P6, class P7, class P8, class P9>
  2533.   Variant Variant::OlePropertyGet(const String& name,
  2534.     P1 p1, P2 p2, P3 p3, P4 p4, P5 p5,
  2535.     P6 p6, P7 p7, P8 p8, P9 p9)
  2536.   {
  2537.     TAutoArgs<9> args;
  2538.     args[1] = p1;  args[2] = p2;  args[3] = p3;
  2539.     args[4] = p4;  args[5] = p5;  args[6] = p6;
  2540.     args[7] = p7;  args[8] = p8;  args[9] = p9;
  2541.     return OlePropertyGet(name, static_cast<TAutoArgsBase*>(&args));
  2542.   }
  2543.  
  2544.   template <class P1, class P2, class P3, class P4, class P5,
  2545.             class P6, class P7, class P8, class P9, class P10>
  2546.   Variant Variant::OlePropertyGet(const String& name,
  2547.     P1 p1, P2 p2, P3 p3, P4 p4, P5 p5,
  2548.     P6 p6, P7 p7, P8 p8, P9 p9, P10 p10)
  2549.   {
  2550.     TAutoArgs<10> args;
  2551.     args[1] = p1;  args[2] = p2;  args[3] = p3;
  2552.     args[4] = p4;  args[5] = p5;  args[6] = p6;
  2553.     args[7] = p7;  args[8] = p8;  args[9] = p9;
  2554.     args[10] = p10;
  2555.     return OlePropertyGet(name, static_cast<TAutoArgsBase*>(&args));
  2556.   }
  2557.  
  2558.   template <class P1>
  2559.   void Variant::OlePropertySet(const String& name, P1 p1)
  2560.   {
  2561.     TAutoArgs<1> args;
  2562.     args[1] = p1;
  2563.     OlePropertySet(name, static_cast<TAutoArgsBase&>(args));
  2564.   }
  2565.  
  2566.   template <class P1, class P2>
  2567.   void Variant::OlePropertySet(const String& name, P1 p1, P2 p2)
  2568.   {
  2569.     TAutoArgs<2> args;
  2570.     args[1] = p1;  args[2] = p2;
  2571.     OlePropertySet(name, static_cast<TAutoArgsBase&>(args));
  2572.   }
  2573.  
  2574.   template <class P1, class P2, class P3>
  2575.   void Variant::OlePropertySet(const String& name, P1 p1, P2 p2, P3 p3)
  2576.   {
  2577.     TAutoArgs<3> args;
  2578.     args[1] = p1;  args[2] = p2;  args[3] = p3;
  2579.     OlePropertySet(name, static_cast<TAutoArgsBase&>(args));
  2580.   }
  2581.  
  2582.   template <class P1, class P2, class P3, class P4>
  2583.   void Variant::OlePropertySet(const String& name, P1 p1, P2 p2, P3 p3, P4 p4)
  2584.   {
  2585.     TAutoArgs<4> args;
  2586.     args[1] = p1;  args[2] = p2;  args[3] = p3;
  2587.     args[4] = p4;
  2588.     OlePropertySet(name, static_cast<TAutoArgsBase&>(args));
  2589.   }
  2590.  
  2591.   template <class P1, class P2, class P3, class P4, class P5>
  2592.   void Variant::OlePropertySet(const String& name, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
  2593.   {
  2594.     TAutoArgs<5> args;
  2595.     args[1] = p1;  args[2] = p2;  args[3] = p3;
  2596.     args[4] = p4;  args[5] = p5;
  2597.     OlePropertySet(name, static_cast<TAutoArgsBase&>(args));
  2598.   }
  2599.  
  2600.   template <class P1, class P2, class P3, class P4, class P5,
  2601.             class P6>
  2602.   void Variant::OlePropertySet(const String& name,
  2603.     P1 p1, P2 p2, P3 p3, P4 p4, P5 p5,
  2604.     P6 p6)
  2605.   {
  2606.     TAutoArgs<6> args;
  2607.     args[1] = p1;  args[2] = p2;  args[3] = p3;
  2608.     args[4] = p4;  args[5] = p5;  args[6] = p6;
  2609.     OlePropertySet(name, static_cast<TAutoArgsBase&>(args));
  2610.   }
  2611.  
  2612.   template <class P1, class P2, class P3, class P4, class P5,
  2613.             class P6, class P7>
  2614.   void Variant::OlePropertySet(const String& name,
  2615.     P1 p1, P2 p2, P3 p3, P4 p4, P5 p5,
  2616.     P6 p6, P7 p7)
  2617.   {
  2618.     TAutoArgs<7> args;
  2619.     args[1] = p1;  args[2] = p2;  args[3] = p3;
  2620.     args[4] = p4;  args[5] = p5;  args[6] = p6;
  2621.     args[7] = p7;
  2622.     OlePropertySet(name, static_cast<TAutoArgsBase&>(args));
  2623.   }
  2624.  
  2625.   template <class P1, class P2, class P3, class P4, class P5,
  2626.             class P6, class P7, class P8>
  2627.   void Variant::OlePropertySet(const String& name,
  2628.     P1 p1, P2 p2, P3 p3, P4 p4, P5 p5,
  2629.     P6 p6, P7 p7, P8 p8)
  2630.   {
  2631.     TAutoArgs<8> args;
  2632.     args[1] = p1;  args[2] = p2;  args[3] = p3;
  2633.     args[4] = p4;  args[5] = p5;  args[6] = p6;
  2634.     args[7] = p7;  args[8] = p8;
  2635.     OlePropertySet(name, static_cast<TAutoArgsBase&>(args));
  2636.   }
  2637.  
  2638.   template <class P1, class P2, class P3, class P4, class P5,
  2639.             class P6, class P7, class P8, class P9>
  2640.   void Variant::OlePropertySet(const String& name,
  2641.     P1 p1, P2 p2, P3 p3, P4 p4, P5 p5,
  2642.     P6 p6, P7 p7, P8 p8, P9 p9)
  2643.   {
  2644.     TAutoArgs<9> args;
  2645.     args[1] = p1;  args[2] = p2;  args[3] = p3;
  2646.     args[4] = p4;  args[5] = p5;  args[6] = p6;
  2647.     args[7] = p7;  args[8] = p8;  args[9] = p9;
  2648.     OlePropertySet(name, static_cast<TAutoArgsBase&>(args));
  2649.   }
  2650.  
  2651.   template <class P1, class P2, class P3, class P4, class P5,
  2652.             class P6, class P7, class P8, class P9, class P10>
  2653.   void Variant::OlePropertySet(const String& name,
  2654.     P1 p1, P2 p2, P3 p3, P4 p4, P5 p5,
  2655.     P6 p6, P7 p7, P8 p8, P9 p9, P10 p10)
  2656.   {
  2657.     TAutoArgs<10> args;
  2658.     args[1] = p1;  args[2] = p2;  args[3] = p3;
  2659.     args[4] = p4;  args[5] = p5;  args[6] = p6;
  2660.     args[7] = p7;  args[8] = p8;  args[9] = p9;
  2661.     args[10] = p10;
  2662.     OlePropertySet(name, static_cast<TAutoArgsBase&>(args));
  2663.   }
  2664.  
  2665.  
  2666.  
  2667.   class RTL_DELPHIRETURN OleVariant: protected Variant
  2668.   {
  2669.   public:
  2670.     __fastcall OleVariant()                     : Variant()     {}
  2671.     __fastcall OleVariant(const OleVariant& src): Variant(src)  {}
  2672.     __fastcall OleVariant(const Variant& src)   : Variant()     {
  2673.       // To handle Variants that contain non-standard AnsiStrings
  2674.       //
  2675.       *this = src;
  2676.     }
  2677.  
  2678.     //By value constructors
  2679.     __fastcall OleVariant(const short src)      : Variant(src)  {}
  2680.     __fastcall OleVariant(const int src)        : Variant(src)  {}
  2681.     __fastcall OleVariant(const float src)      : Variant(src)  {}
  2682.     __fastcall OleVariant(const double src)     : Variant(src)  {}
  2683.     __fastcall OleVariant(const Currency src)   : Variant(src)  {}
  2684.     __fastcall OleVariant(const TDateTime src)  : Variant(src)  {}
  2685.     __fastcall OleVariant(const WideString& src): Variant(src)  {}
  2686.     __fastcall OleVariant(const bool src)       : Variant(src)  {}
  2687.     __fastcall OleVariant(const Byte src)       : Variant(src)  {}
  2688.     __fastcall OleVariant(const AnsiString& src): Variant(WideString(src).Detach()) {}
  2689.  
  2690.  
  2691.     __fastcall OleVariant(wchar_t* const src)   : Variant(src)  {}
  2692.     __fastcall OleVariant(IDispatch* const src) : Variant(src)  {}
  2693.     __fastcall OleVariant(IUnknown* const src)  : Variant(src)  {}
  2694.     __fastcall OleVariant(VARIANT* src)         : Variant(src)  {}
  2695.  
  2696.     //By ref constructors
  2697.     __fastcall OleVariant(short* src)           : Variant(src)  {}
  2698.     __fastcall OleVariant(int* src)             : Variant(src)  {}
  2699.     __fastcall OleVariant(float* src)           : Variant(src)  {}
  2700.     __fastcall OleVariant(double* src)          : Variant(src)  {}
  2701.     __fastcall OleVariant(Currency* src)        : Variant(src)  {}
  2702.     __fastcall OleVariant(TDateTime* src)       : Variant(src)  {}
  2703.     __fastcall OleVariant(WordBool* src)        : Variant(src)  {}
  2704.     __fastcall OleVariant(Byte* src)            : Variant(src)  {}
  2705.     __fastcall OleVariant(wchar_t** src)        : Variant(src)  {}
  2706.  
  2707.     // constructor for array of variants of type varType
  2708.     __fastcall OleVariant(const int* bounds, const int boundsSize, Word varType)  :   Variant(bounds, boundsSize, varType) {}
  2709.  
  2710.     // constructor for one dimensional array of type OleVariant
  2711.     __fastcall OleVariant(const OleVariant* values, const int valuesSize) : Variant(values, valuesSize) {}
  2712.  
  2713.     __fastcall ~OleVariant() {}
  2714.  
  2715.  
  2716.     // Assignment operators
  2717.     //
  2718.     OleVariant& __fastcall operator =(const OleVariant& rhs)
  2719.     {
  2720.       PVariant(this)->operator=(rhs);
  2721.       return *this;
  2722.     }
  2723.     OleVariant& __fastcall operator =(const Variant& rhs)
  2724.     {
  2725.       PVariant(this)->operator=(rhs.Sanitized());
  2726.       return *this;
  2727.     }
  2728.     OleVariant& __fastcall operator =(VARIANT& rhs)
  2729.     {
  2730.       PVariant(this)->operator=(rhs);
  2731.       return *this;
  2732.     }
  2733.  
  2734.     OleVariant& __fastcall operator =(const AnsiString& rhs)
  2735.     {
  2736.       PVariant(this)->operator=(WideString(rhs).Detach());
  2737.       return *this;
  2738.     }
  2739.  
  2740.   public:
  2741.  
  2742.     TVarData::VType;
  2743.     TVarData::Reserved1;
  2744.     TVarData::Reserved2;
  2745.     TVarData::Reserved3;
  2746.     TVarData::VSmallint;
  2747.     TVarData::VInteger;
  2748.     TVarData::VSingle;
  2749.     TVarData::VDouble;
  2750.     TVarData::VCurrency;
  2751.     TVarData::VDate;
  2752.     TVarData::VOleStr;
  2753.     TVarData::VDispatch;
  2754.     TVarData::VError;
  2755.     TVarData::VBoolean;
  2756.     TVarData::VUnknown;
  2757.     TVarData::VByte;
  2758.  
  2759.     /*  (Hide this - OleVariant cannot hold MBCS string)
  2760.     TVarData::VString;
  2761.     */
  2762.     TVarData::VArray;
  2763.     TVarData::VPointer;
  2764.  
  2765.  
  2766.     Variant::operator += ;
  2767.     Variant::operator -= ;
  2768.     Variant::operator *= ;
  2769.     Variant::operator /= ;
  2770.     Variant::operator %= ;
  2771.     Variant::operator &= ;
  2772.     Variant::operator |= ;
  2773.     Variant::operator ^= ;
  2774.     Variant::operator <<=;
  2775.     Variant::operator >>=;
  2776.  
  2777.     // comparisons (Variant on right)
  2778.     Variant::operator == ;
  2779.     Variant::operator != ;
  2780.     Variant::operator <  ;
  2781.     Variant::operator >  ;
  2782.     Variant::operator <= ;
  2783.     Variant::operator >= ;
  2784.  
  2785.     // unary operators
  2786.     Variant::operator -;
  2787.     Variant::operator !;
  2788.  
  2789.     // conversion operators
  2790.     Variant::operator short;
  2791.     Variant::operator int;
  2792.     Variant::operator float;
  2793.     Variant::operator double;
  2794.     Variant::operator Currency;
  2795.     Variant::operator TDateTime;
  2796.     Variant::operator bool;
  2797.     Variant::operator WideString;
  2798.     Variant::operator unsigned short;
  2799.     Variant::operator IDispatch*;
  2800.     Variant::operator IUnknown*;
  2801.     Variant::operator VARIANT;
  2802.     Variant::operator TVariant;
  2803.  
  2804.  
  2805.     // by ref conversion operators
  2806.     Variant::operator short*;
  2807.     Variant::operator int*;
  2808.     Variant::operator float*;
  2809.     Variant::operator double*;
  2810.     Variant::operator Currency*;
  2811.     Variant::operator TDateTime*;
  2812.     Variant::operator unsigned short*;
  2813.     Variant::operator Byte*;
  2814.     Variant::operator wchar_t**;
  2815.     Variant::operator VARIANT*;
  2816.     Variant::operator TVariant*;
  2817.  
  2818.  
  2819.     // HRESULT methods
  2820.     Variant::SetError;
  2821.     Variant::GetError;
  2822.  
  2823.     Variant::Clear;
  2824.     Variant::ChangeType;
  2825.     Variant::AsType;
  2826.  
  2827.     Variant::Type;
  2828.     Variant::IsNull;
  2829.     Variant::IsEmpty;
  2830.  
  2831.     // variant array stuff
  2832.     Variant::IsArray;
  2833.     Variant::GetElement;
  2834.     Variant::PutElement;
  2835.     Variant::ArrayDimCount;
  2836.     Variant::ArrayLowBound;
  2837.     Variant::ArrayHighBound;
  2838.     Variant::ArrayRedim;
  2839.     Variant::ArrayLock;
  2840.     Variant::ArrayUnlock;
  2841.  
  2842.     // Automation Goodies
  2843.     Variant::Exec;
  2844.  
  2845.     // Alternate Syntax for Automation
  2846.     Variant::OleProcedure;
  2847.     Variant::OleFunction;
  2848.     Variant::OlePropertyGet;
  2849.     Variant::OlePropertySet;
  2850.  
  2851.   private:
  2852.  
  2853.     // binary operators (AnsiString on right)
  2854.     OleVariant __fastcall operator * (const AnsiString& rhs) const;
  2855.     OleVariant __fastcall operator / (const AnsiString& rhs) const;
  2856.     OleVariant __fastcall operator % (const AnsiString& rhs) const;
  2857.     OleVariant __fastcall operator & (const AnsiString& rhs) const;
  2858.     OleVariant __fastcall operator | (const AnsiString& rhs) const;
  2859.     OleVariant __fastcall operator ^ (const AnsiString& rhs) const;
  2860.     OleVariant __fastcall operator <<(const AnsiString& rhs) const;
  2861.     OleVariant __fastcall operator >>(const AnsiString& rhs) const;
  2862.   };
  2863.  
  2864. // Variant global scope comparisons (int on left)
  2865.   inline bool __fastcall operator ==(int lhs, const Variant& rhs)
  2866.   {return Variant(lhs).operator ==(rhs);}
  2867.   inline bool __fastcall operator !=(int lhs, const Variant& rhs)
  2868.   {return Variant(lhs).operator !=(rhs);}
  2869.   inline bool __fastcall operator < (int lhs, const Variant& rhs)
  2870.   {return Variant(lhs).operator < (rhs);}
  2871.   inline bool __fastcall operator > (int lhs, const Variant& rhs)
  2872.   {return Variant(lhs).operator > (rhs);}
  2873.   inline bool __fastcall operator <=(int lhs, const Variant& rhs)
  2874.   {return Variant(lhs).operator <=(rhs);}
  2875.   inline bool __fastcall operator >=(int lhs, const Variant& rhs)
  2876.   {return Variant(lhs).operator >=(rhs);}
  2877.  
  2878. // Variant global scope comparisons (double on left)
  2879.   inline bool __fastcall operator ==(double lhs, const Variant& rhs)
  2880.   {return Variant(lhs).operator ==(rhs);}
  2881.   inline bool __fastcall operator !=(double lhs, const Variant& rhs)
  2882.   {return Variant(lhs).operator !=(rhs);}
  2883.   inline bool __fastcall operator < (double lhs, const Variant& rhs)
  2884.   {return Variant(lhs).operator < (rhs);}
  2885.   inline bool __fastcall operator > (double lhs, const Variant& rhs)
  2886.   {return Variant(lhs).operator > (rhs);}
  2887.   inline bool __fastcall operator <=(double lhs, const Variant& rhs)
  2888.   {return Variant(lhs).operator <=(rhs);}
  2889.   inline bool __fastcall operator >=(double lhs, const Variant& rhs)
  2890.   {return Variant(lhs).operator >=(rhs);}
  2891.  
  2892. // Variant binary global scope operators (AnsiString on left)
  2893.   inline Variant __fastcall operator - (const AnsiString& lhs, const Variant& rhs)
  2894.   {return Variant(lhs).operator -(rhs);}
  2895.   inline Variant __fastcall operator * (const AnsiString& lhs, const Variant& rhs)
  2896.   {return Variant(lhs).operator *(rhs);}
  2897.   inline Variant __fastcall operator / (const AnsiString& lhs, const Variant& rhs)
  2898.   {return Variant(lhs).operator /(rhs);}
  2899.   inline Variant __fastcall operator % (const AnsiString& lhs, const Variant& rhs)
  2900.   {return Variant(lhs).operator %(rhs);}
  2901.   inline Variant __fastcall operator & (const AnsiString& lhs, const Variant& rhs)
  2902.   {return Variant(lhs).operator &(rhs);}
  2903.   inline Variant __fastcall operator | (const AnsiString& lhs, const Variant& rhs)
  2904.   {return Variant(lhs).operator |(rhs);}
  2905.   inline Variant __fastcall operator ^ (const AnsiString& lhs, const Variant& rhs)
  2906.   {return Variant(lhs).operator ^(rhs);}
  2907.   inline Variant __fastcall operator <<(const AnsiString& lhs, const Variant& rhs)
  2908.   {return Variant(lhs).operator <<(rhs);}
  2909.   inline Variant __fastcall operator >>(const AnsiString& lhs, const Variant& rhs)
  2910.   {return Variant(lhs).operator >>(rhs);}
  2911.  
  2912. // Variant binary global scope operators (int on left)
  2913.   inline Variant __fastcall operator +(int lhs, const Variant& rhs)
  2914.   {return Variant(lhs).operator +(rhs);}
  2915.   inline Variant __fastcall operator -(int lhs, const Variant& rhs)
  2916.   {return Variant(lhs).operator -(rhs);}
  2917.   inline Variant __fastcall operator *(int lhs, const Variant& rhs)
  2918.   {return Variant(lhs).operator *(rhs);}
  2919.   inline Variant __fastcall operator /(int lhs, const Variant& rhs)
  2920.   {return Variant(lhs).operator /(rhs);}
  2921.   inline Variant __fastcall operator %(int lhs, const Variant& rhs)
  2922.   {return Variant(lhs).operator %(rhs);}
  2923.   inline Variant __fastcall operator &(int lhs, const Variant& rhs)
  2924.   {return Variant(lhs).operator &(rhs);}
  2925.   inline Variant __fastcall operator |(int lhs, const Variant& rhs)
  2926.   {return Variant(lhs).operator |(rhs);}
  2927.   inline Variant __fastcall operator ^(int lhs, const Variant& rhs)
  2928.   {return Variant(lhs).operator ^(rhs);}
  2929.   inline Variant __fastcall operator <<(int lhs, const Variant& rhs)
  2930.   {return Variant(lhs).operator <<(rhs);}
  2931.   inline Variant __fastcall operator >>(int lhs, const Variant& rhs)
  2932.   {return Variant(lhs).operator >>(rhs);}
  2933.  
  2934. // Variant binary global scope operators (double on left)
  2935.   inline Variant __fastcall operator +(double lhs, const Variant& rhs)
  2936.   {return Variant(lhs).operator +(rhs);}
  2937.   inline Variant __fastcall operator -(double lhs, const Variant& rhs)
  2938.   {return Variant(lhs).operator -(rhs);}
  2939.   inline Variant __fastcall operator *(double lhs, const Variant& rhs)
  2940.   {return Variant(lhs).operator *(rhs);}
  2941.   inline Variant __fastcall operator /(double lhs, const Variant& rhs)
  2942.   {return Variant(lhs).operator /(rhs);}
  2943.   inline Variant __fastcall operator %(double lhs, const Variant& rhs)
  2944.   {return Variant(lhs).operator %(rhs);}
  2945.   inline Variant __fastcall operator &(double lhs, const Variant& rhs)
  2946.   {return Variant(lhs).operator &(rhs);}
  2947.   inline Variant __fastcall operator |(double lhs, const Variant& rhs)
  2948.   {return Variant(lhs).operator |(rhs);}
  2949.   inline Variant __fastcall operator ^(double lhs, const Variant& rhs)
  2950.   {return Variant(lhs).operator ^(rhs);}
  2951.   inline Variant __fastcall operator <<(double lhs, const Variant& rhs)
  2952.   {return Variant(lhs).operator <<(rhs);}
  2953.   inline Variant __fastcall operator >>(double lhs, const Variant& rhs)
  2954.   {return Variant(lhs).operator >>(rhs);}
  2955.  
  2956.   class NamedParm;
  2957.   class AutoCmd
  2958.   {
  2959.   public:
  2960.     AutoCmd(const String& name);
  2961.     AutoCmd(const AutoCmd& src);
  2962.    ~AutoCmd();
  2963.  
  2964.     // Set(update) name of command
  2965.     AutoCmd& SetName(const String& name);
  2966.  
  2967.     // Named arg
  2968.     AutoCmd& operator <<(const NamedParm& np);
  2969.  
  2970.     // By value args
  2971.     AutoCmd& operator <<(const Variant& arg);
  2972.     AutoCmd& operator <<(const short arg);
  2973.     AutoCmd& operator <<(const int arg);
  2974.     AutoCmd& operator <<(const float arg);
  2975.     AutoCmd& operator <<(const double arg);
  2976.     AutoCmd& operator <<(const Currency arg);
  2977.     AutoCmd& operator <<(const TDateTime arg);
  2978.     AutoCmd& operator <<(const bool arg);
  2979.     AutoCmd& operator <<(const WordBool arg);
  2980.     AutoCmd& operator <<(const Byte arg);
  2981.     AutoCmd& operator <<(const AnsiString& arg);
  2982.  
  2983.     // Treat 'const char*' as an ASCIIz string
  2984.     AutoCmd& operator <<(const char* arg) {return operator <<(WideString(arg));}
  2985.  
  2986.     AutoCmd& operator <<(wchar_t* arg);
  2987.     AutoCmd& operator <<(IDispatch* arg);
  2988.     AutoCmd& operator <<(IUnknown* arg);
  2989.  
  2990.     //By ref args
  2991.     AutoCmd& operator <<(Variant* arg);
  2992.     AutoCmd& operator <<(short* arg);
  2993.     AutoCmd& operator <<(int* arg);
  2994.     AutoCmd& operator <<(float* arg);
  2995.     AutoCmd& operator <<(double* arg);
  2996.     AutoCmd& operator <<(Currency* arg);
  2997.     AutoCmd& operator <<(TDateTime* arg);
  2998.     AutoCmd& operator <<(WordBool* arg);
  2999.     AutoCmd& operator <<(Byte* arg);
  3000.     AutoCmd& operator <<(wchar_t** arg);
  3001.  
  3002.     AutoCmd& operator <<(AnsiString* arg);
  3003.  
  3004.     AutoCmd&          Clear();                 // ClearName() + ClearArgs()
  3005.     AutoCmd&          ClearName();             // SetName("")
  3006.     AutoCmd&          ClearArgs();             // Clear Parms and NamedParms
  3007.  
  3008.     // Overriden in Procedure, Function, PropertyGet and PropertySet classes
  3009.     //
  3010.     virtual Byte      GetCallType()   const = 0;
  3011.     virtual bool      RequestResult() const = 0;
  3012.  
  3013.     int               GetArgType(const Byte idx) const;
  3014.     int               GetNamedArgType(const Byte idx) const;
  3015.     String            GetName() const { return Name;}
  3016.     Byte              GetArgCount() const;
  3017.     Byte              GetNamedArgCount() const;
  3018.     Variant&          GetParm(const Byte idx);
  3019.     Variant&          GetNamedParm(const Byte idx);
  3020.     String            GetNamedParmName(const Byte idx) const;
  3021.  
  3022.   protected:
  3023.     void              AddElement();
  3024.     String            Name;                             // name of command
  3025.     Variant           Parms;                            // positional arguments
  3026.     Variant           ParmTypes;                        // types of positional arguments
  3027.     Variant           NamedParms;                       // named arguments
  3028.     Variant           NamedParmTypes;                   // types of named arguments
  3029.     Variant           NamedParmNames;                   // names of named arguments
  3030.   };
  3031.  
  3032.   class NamedParm
  3033.   {
  3034.   public:
  3035.     //By value ctors
  3036.     NamedParm(const String& name, const Variant& arg):    Name(name), Type(varVariant), Parm(arg) {}
  3037.     NamedParm(const String& name, const short arg):       Name(name), Type(varSmallint), Parm(arg) {}
  3038.     NamedParm(const String& name, const int arg):         Name(name), Type(varInteger), Parm(arg) {}
  3039.     NamedParm(const String& name, const float arg):       Name(name), Type(varSingle), Parm(arg) {}
  3040.     NamedParm(const String& name, const double arg):      Name(name), Type(varDouble), Parm(arg) {}
  3041.     NamedParm(const String& name, const Currency arg):    Name(name), Type(varCurrency), Parm(arg) {}
  3042.     NamedParm(const String& name, const TDateTime arg):   Name(name), Type(varDate), Parm(arg) {}
  3043.     NamedParm(const String& name, const bool arg):        Name(name), Type(varBoolean), Parm(arg) {}
  3044.     NamedParm(const String& name, const WordBool arg):    Name(name), Type(varBoolean), Parm(arg) {}
  3045.     NamedParm(const String& name, const Byte arg):        Name(name), Type(varByte), Parm(arg) {}
  3046.     NamedParm(const String& name, const AnsiString& arg): Name(name), Type(varOleStr), Parm(WideString(arg).Detach()) {}
  3047.     NamedParm(const String& name, const char* arg):       Name(name), Type(varOleStr), Parm(WideString(arg).Detach()) {}
  3048.     NamedParm(const String& name, wchar_t* /*BSTR*/ arg): Name(name), Type(varOleStr), Parm(arg) {}
  3049.     NamedParm(const String& name, IDispatch* const arg):  Name(name), Type(varDispatch), Parm(arg) {}
  3050.     NamedParm(const String& name, IUnknown* const arg):   Name(name), Type(varUnknown), Parm(arg) {}
  3051.  
  3052.     //By ref ctors
  3053.     NamedParm(const String& name, Variant* arg):   Name(name), Type(varVariant | varByRef), Parm(arg) {}
  3054.     NamedParm(const String& name, short* arg):     Name(name), Type(varSmallint | varByRef), Parm(arg) {}
  3055.     NamedParm(const String& name, int* arg):       Name(name), Type(varInteger | varByRef), Parm(arg) {}
  3056.     NamedParm(const String& name, float* arg):     Name(name), Type(varSingle | varByRef), Parm(arg) {}
  3057.     NamedParm(const String& name, double* arg):    Name(name), Type(varDouble | varByRef), Parm(arg) {}
  3058.     NamedParm(const String& name, Currency* arg):  Name(name), Type(varCurrency | varByRef), Parm(arg) {}
  3059.     NamedParm(const String& name, TDateTime* arg): Name(name), Type(varDate | varByRef), Parm(arg) {}
  3060.     NamedParm(const String& name, WordBool* arg):  Name(name), Type(varBoolean | varByRef), Parm(arg) {}
  3061.     NamedParm(const String& name, Byte* arg):      Name(name), Type(varByte | varByRef), Parm(arg) {}
  3062.     NamedParm(const String& name, wchar_t** arg):  Name(name), Type(varOleStr | varByRef), Parm(arg) {}
  3063.     NamedParm(const String& name, String* arg):    Name(name), Type(varOleStr), Parm(WideString(*arg).Detach()) {}
  3064.  
  3065.     Variant           GetParm() const     { return Parm;}
  3066.     int               GetType() const     { return Type;}
  3067.     String            GetParmName() const { return Name;}
  3068.   protected:
  3069.     void              AddElement();
  3070.     String            Name;
  3071.     Variant           Parm;
  3072.     int               Type;
  3073.   };
  3074.  
  3075.  
  3076.   class Procedure : public AutoCmd
  3077.   {
  3078.   public:
  3079.     Procedure(const String& name): AutoCmd(name) {}
  3080.     Procedure(const AutoCmd& src): AutoCmd(src)  {}
  3081.     Byte      GetCallType()   const { return DISPATCH_METHOD;}
  3082.     bool      RequestResult() const { return false;          }
  3083.   };
  3084.  
  3085.   class Function : public AutoCmd
  3086.   {
  3087.   public:
  3088.     Function(const String& name): AutoCmd(name) {}
  3089.     Function(const AutoCmd& src): AutoCmd(src)  {}
  3090.     Byte      GetCallType()   const { return DISPATCH_METHOD;}
  3091.     bool      RequestResult() const { return true;           }
  3092.   };
  3093.  
  3094.   class PropertySet : public AutoCmd
  3095.   {
  3096.   public:
  3097.     PropertySet(const String& name): AutoCmd(name) {}
  3098.     PropertySet(const AutoCmd& src): AutoCmd(src)  {}
  3099.     Byte      GetCallType()   const { return DISPATCH_PROPERTYPUT; }
  3100.     bool      RequestResult() const { return false;                }
  3101.   };
  3102.  
  3103.   class PropertyGet : public AutoCmd
  3104.   {
  3105.   public:
  3106.     PropertyGet(const String& name): AutoCmd(name) {}
  3107.     PropertyGet(const AutoCmd& src): AutoCmd(src)  {}
  3108.     Byte      GetCallType()   const { return DISPATCH_PROPERTYGET;}
  3109.     bool      RequestResult() const { return true;                }
  3110.   };
  3111.  
  3112.   extern void __fastcall  VarClear(Variant& v); /* variant.cpp */
  3113.   extern void __fastcall  VarCast(Variant &dest, const Variant& source, int type); /* variant.cpp */
  3114.   extern void __fastcall  VarArrayRedim(Variant& a, int high); /* variant.cpp */
  3115.  
  3116. }
  3117.  
  3118. #pragma option pop
  3119.  
  3120.  
  3121. // VARIANT, Variant, TVariant and OleVariant - some many deviations - Ensure they're in alignment!
  3122. //
  3123. #if 0
  3124. #if sizeof(TVarData) < sizeof(VARIANT)
  3125. #pragma message "ERROR: sizeof(TVarData) < sizeof(VARIANT)'
  3126. #endif
  3127. #if sizeof(TVarData) > sizeof(VARIANT)
  3128. #pragma message "ERROR: sizeof(TVarData) > sizeof(VARIANT)'
  3129. #endif
  3130. #if sizeof(OleVariant) < sizeof(VARIANT)
  3131. #pragma message "ERROR: sizeof(OleVariant) < sizeof(VARIANT)'
  3132. #endif
  3133. #if sizeof(OleVariant) > sizeof(VARIANT)
  3134. #pragma message "ERROR: sizeof(OleVariant) > sizeof(VARIANT)'
  3135. #endif
  3136. #endif
  3137.  
  3138.  
  3139. #endif
  3140.