home *** CD-ROM | disk | FTP | other *** search
/ Chip 1997 April / Chip_1997-04_cd.bin / prezent / cb / data.z / VARIANT.CPP < prev    next >
Text File  |  1997-01-16  |  57KB  |  2,495 lines
  1. //---------------------------------------------------------------------------
  2. //    variant.cpp - support for delphi variants in cpp
  3. //---------------------------------------------------------------------------
  4. // $Revision:   1.39  $
  5. //-------------------------------------------------------------------------
  6. //    copyright (c) 1996 Borland International
  7. //----------------------------------------------------------------------------
  8. #pragma inline
  9.  
  10. // PRONTO_NAMESPACES must be defined when .HPP headers where generated
  11. // with namespace enabled.. (BB)
  12. //
  13. // #define PRONTO_NAMESPACES
  14.  
  15. #include<windows.hpp>
  16. #include<ole2.hpp>
  17. #include<oleauto.hpp>
  18. #include <sysutils.hpp>
  19. #include "variant.hpp"
  20.  
  21. #ifdef near
  22. #undef near
  23. #endif
  24.  
  25. #if defined(PRONTO_NAMESPACES)
  26. namespace System
  27. {
  28. #endif
  29.  
  30. //---------------------------------------------------------------------------
  31.  
  32. //statics
  33. Variant __fastcall Variant::CreateObject(const String& ProgID)
  34. {
  35. #if defined(PRONTO_NAMESPACES)
  36.   return Oleauto::CreateOleObject(const_cast<String&>(ProgID));
  37. #else
  38.   return ::CreateOleObject(const_cast<String&>(ProgID));
  39. #endif
  40. }
  41.  
  42. Variant __fastcall Variant::GetActiveObject(const String& ProgID)
  43. {
  44. #if defined(PRONTO_NAMESPACES)
  45.   return Oleauto::GetActiveOleObject(const_cast<String&>(ProgID));
  46. #else
  47.   return ::GetActiveOleObject(const_cast<String&>(ProgID));
  48. #endif
  49. }
  50.  
  51. //ctors
  52. __fastcall Variant::Variant()
  53. {
  54.   VariantInit(reinterpret_cast<VARIANTARG *>(this));
  55. }
  56.  
  57. __fastcall Variant::Variant(const Variant& rhs)
  58. {
  59.   VariantInit(reinterpret_cast<VARIANTARG *>(this));
  60.  
  61. #if defined(PRONTO_NAMESPACES)
  62.   System::VarCopyNoInd(*this, rhs);
  63. #else
  64.   ::VarCopyNoInd(*this, rhs);
  65. #endif
  66. }
  67.  
  68. __fastcall Variant::Variant(const short src)
  69. {
  70.   VariantInit(reinterpret_cast<VARIANTARG *>(this));
  71.   VType = varSmallint;
  72.   VSmallint = src;
  73. }
  74.  
  75. __fastcall Variant::Variant(const int src)
  76. {
  77.   VariantInit(reinterpret_cast<VARIANTARG *>(this));
  78.   VType = varInteger;
  79.   VInteger = src;
  80. }
  81.  
  82. __fastcall Variant::Variant(const float src)
  83. {
  84.   VariantInit(reinterpret_cast<VARIANTARG *>(this));
  85.   VType = varSingle;
  86.   VSingle = src;
  87. }
  88.  
  89. __fastcall Variant::Variant(const double src)
  90. {
  91.   VariantInit(reinterpret_cast<VARIANTARG *>(this));
  92.   VType = varDouble;
  93.   VDouble = src;
  94. }
  95.  
  96. __fastcall Variant::Variant(const Currency src)
  97. {
  98.   VariantInit(reinterpret_cast<VARIANTARG *>(this));
  99.   VType = varCurrency;
  100.   VCurrency = src;
  101. }
  102.  
  103. __fastcall Variant::Variant(const TDateTime src)
  104. {
  105.   VariantInit(reinterpret_cast<VARIANTARG *>(this));
  106.   VType = varDate;
  107.   VDate = src;
  108. }
  109.  
  110. __fastcall Variant::Variant(const bool src)
  111. {
  112.   VariantInit(reinterpret_cast<VARIANTARG *>(this));
  113.   VType = varBoolean;
  114.   VBoolean = src;
  115. }
  116.  
  117. __fastcall Variant::Variant(const WordBool src)
  118. {
  119.   VariantInit(reinterpret_cast<VARIANTARG *>(this));
  120.   VType = varBoolean;
  121.   VBoolean = src;
  122. }
  123.  
  124. __fastcall Variant::Variant(const Byte src)
  125. {
  126.   VariantInit(reinterpret_cast<VARIANTARG *>(this));
  127.   VType = varByte;
  128.   VByte = src;
  129. }
  130.  
  131. __fastcall Variant::Variant(const String& src)
  132. {
  133.   VariantInit(reinterpret_cast<VARIANTARG *>(this));
  134.   VType = varString;
  135.   VString = 0;
  136.   (AnsiString&)VString = src;
  137. }
  138.  
  139. //!JK for now, I'm treating this as a character array
  140. //!JK but it could also be viewed as a character by reference!!!!
  141. __fastcall Variant::Variant(const char* src)
  142. {
  143.   VariantInit(reinterpret_cast<VARIANTARG *>(this));
  144.   VType = varString;
  145.   VString = 0;
  146.   (AnsiString&)VString = src;
  147. }
  148.  
  149. __fastcall Variant::Variant(wchar_t* const src)
  150. {
  151.   VariantInit(reinterpret_cast<VARIANTARG *>(this));
  152.   VType = varOleStr;
  153.   VOleStr = SysAllocString(src);
  154. }
  155.  
  156. __fastcall Variant::Variant(Ole2::IDispatch* const src)
  157. {
  158.   VariantInit(reinterpret_cast<VARIANTARG *>(this));
  159.   VType = varDispatch;
  160.   if (src)
  161.     src->AddRef();
  162.   VDispatch = src;
  163. }
  164.  
  165. __fastcall Variant::Variant(Ole2::IUnknown* const src)
  166. {
  167.   VariantInit(reinterpret_cast<VARIANTARG *>(this));
  168.   VType = varUnknown;
  169.   if (src)
  170.     src->AddRef();
  171.   VUnknown = src;
  172. }
  173.  
  174. //ByRef constructors
  175. __fastcall Variant::Variant(short* src)
  176. {
  177.   VariantInit(reinterpret_cast<VARIANTARG *>(this));
  178.   VType = varSmallint | varByRef;
  179.   VPointer = src;
  180. }
  181.  
  182. __fastcall Variant::Variant(int* src)
  183. {
  184.   VariantInit(reinterpret_cast<VARIANTARG *>(this));
  185.   VType = varInteger | varByRef;
  186.   VPointer = src;
  187. }
  188.  
  189. __fastcall Variant::Variant(float* src)
  190. {
  191.   VariantInit(reinterpret_cast<VARIANTARG *>(this));
  192.   VType = varSingle | varByRef;
  193.   VPointer = src;
  194. }
  195.  
  196. __fastcall Variant::Variant(double* src)
  197. {
  198.   VariantInit(reinterpret_cast<VARIANTARG *>(this));
  199.   VType = varDouble | varByRef;
  200.   VPointer = src;
  201. }
  202.  
  203. __fastcall Variant::Variant(Currency* src)
  204. {
  205.   VariantInit(reinterpret_cast<VARIANTARG *>(this));
  206.   VType = varCurrency | varByRef;
  207.   VPointer = src;
  208. }
  209.  
  210. __fastcall Variant::Variant(TDateTime* src)
  211. {
  212.   VariantInit(reinterpret_cast<VARIANTARG *>(this));
  213.   VType = varDate | varByRef;
  214.   VPointer = src;
  215. }
  216.  
  217. __fastcall Variant::Variant(WordBool* src)
  218. {
  219.   VariantInit(reinterpret_cast<VARIANTARG *>(this));
  220.   VType = varBoolean | varByRef;
  221.   VPointer = src;
  222. }
  223.  
  224. __fastcall Variant::Variant(Byte* src)
  225. {
  226.   VariantInit(reinterpret_cast<VARIANTARG *>(this));
  227.   VType = varByte | varByRef;
  228.   VPointer = src;
  229. }
  230.  
  231. __fastcall Variant::Variant(wchar_t** src)
  232. {
  233.   VariantInit(reinterpret_cast<VARIANTARG *>(this));
  234.   VType = varOleStr | varByRef;
  235.   VPointer = src;
  236. }
  237.  
  238. //construct a Variant array of type varType
  239. __fastcall Variant::Variant(const int* bounds,const int boundsSize,Word varType)
  240. {
  241.   VariantInit(reinterpret_cast<VARIANTARG *>(this));
  242.  
  243. #if defined(PRONTO_NAMESPACES)
  244.   *this = System::VarArrayCreate(bounds, boundsSize, varType);
  245. #else
  246.   *this = ::VarArrayCreate(bounds, boundsSize, varType);
  247. #endif
  248. }
  249.  
  250. // construct a one dimensional Variant array of type varVariant
  251. // and fill with values
  252. __fastcall Variant::Variant(const Variant* values, const int valuesSize)
  253. {
  254.   VariantInit(reinterpret_cast<VARIANTARG *>(this));
  255.  
  256. #if defined(PRONTO_NAMESPACES)
  257.   *this = System::VarArrayOf(values, valuesSize);
  258. #else
  259.   *this = ::VarArrayOf(values, valuesSize);
  260. #endif
  261. }
  262.  
  263. __fastcall Variant::~Variant()
  264. {
  265. #if defined(PRONTO_NAMESPACES)
  266.   System::VarClear(*this);
  267. #else
  268.   ::VarClear(*this);
  269. #endif
  270. }
  271.  
  272. Variant& __fastcall Variant::operator =(const Variant& rhs)
  273. {
  274. #if defined(PRONTO_NAMESPACES)
  275.   System::VarCopyNoInd(*this, rhs);
  276. #else
  277.   ::VarCopyNoInd(*this, rhs);
  278. #endif
  279.   return *this;
  280. }
  281.  
  282. Variant& __fastcall Variant::operator +=(const Variant&)
  283. {
  284.   asm
  285.   {
  286. #if defined(PRONTO_NAMESPACES)
  287.     extrn   @System@@VarAdd$qqrv:near
  288.     call    @System@@VarAdd$qqrv
  289. #else
  290.     extrn   @@VarAdd$qqrv:near
  291.     call    @@VarAdd$qqrv
  292. #endif
  293.   }
  294.   return *this;
  295. }
  296.  
  297. Variant& __fastcall Variant::operator -=(const Variant&)
  298. {
  299.   asm
  300.   {
  301. #if defined(PRONTO_NAMESPACES)
  302.     extrn   @System@@VarSub$qqrv:near
  303.     call    @System@@VarSub$qqrv
  304. #else
  305.     extrn   @@VarSub$qqrv:near
  306.     call    @@VarSub$qqrv
  307. #endif
  308.   }
  309.   return *this;
  310. }
  311.  
  312. Variant& __fastcall Variant::operator *=(const Variant&)
  313. {
  314.   asm
  315.   {
  316. #if defined(PRONTO_NAMESPACES)
  317.     extrn   @System@@VarMul$qqrv:near
  318.     call    @System@@VarMul$qqrv
  319. #else
  320.     extrn   @@VarMul$qqrv:near
  321.     call    @@VarMul$qqrv
  322. #endif
  323.   }
  324.   return *this;
  325. }
  326.  
  327. Variant& __fastcall Variant::operator /=(const Variant&)
  328. {
  329.   asm
  330.   {
  331. #if defined(PRONTO_NAMESPACES)
  332.     extrn   @System@@VarRDiv$qqrv:near
  333.     call    @System@@VarRDiv$qqrv
  334. #else
  335.     extrn   @@VarRDiv$qqrv:near
  336.     call    @@VarRDiv$qqrv
  337. #endif
  338.   }
  339.   return *this;
  340. }
  341.  
  342. Variant& __fastcall Variant::operator %=(const Variant&)
  343. {
  344.   asm
  345.   {
  346. #if defined(PRONTO_NAMESPACES)
  347.     extrn   @System@@VarMod$qqrv:near
  348.     call    @System@@VarMod$qqrv
  349. #else
  350.     extrn   @@VarMod$qqrv:near
  351.     call    @@VarMod$qqrv
  352. #endif
  353.   }
  354.   return *this;
  355. }
  356.  
  357. Variant& __fastcall Variant::operator &=(const Variant&)
  358. {
  359.   asm
  360.   {
  361. #if defined(PRONTO_NAMESPACES)
  362.     extrn   @System@@VarAnd$qqrv:near
  363.     call    @System@@VarAnd$qqrv
  364. #else
  365.     extrn   @@VarAnd$qqrv:near
  366.     call    @@VarAnd$qqrv
  367. #endif
  368.   }
  369.   return *this;
  370. }
  371.  
  372. Variant& __fastcall Variant::operator |=(const Variant&)
  373. {
  374.   asm
  375.   {
  376. #if defined(PRONTO_NAMESPACES)
  377.     extrn   @System@@VarOr$qqrv:near
  378.     call    @System@@VarOr$qqrv
  379. #else
  380.     extrn   @@VarOr$qqrv:near
  381.     call    @@VarOr$qqrv
  382. #endif
  383.   }
  384.   return *this;
  385. }
  386.  
  387. Variant& __fastcall Variant::operator ^=(const Variant&)
  388. {
  389.   asm
  390.   {
  391. #if defined(PRONTO_NAMESPACES)
  392.     extrn   @System@@VarXor$qqrv:near
  393.     call    @System@@VarXor$qqrv
  394. #else
  395.     extrn   @@VarXor$qqrv:near
  396.     call    @@VarXor$qqrv
  397. #endif
  398.   }
  399.   return *this;
  400. }
  401.  
  402. Variant& __fastcall Variant::operator <<=(const Variant&)
  403. {
  404.   asm
  405.   {
  406. #if defined(PRONTO_NAMESPACES)
  407.     extrn   @System@@VarShl$qqrv:near
  408.     call    @System@@VarShl$qqrv
  409. #else
  410.     extrn   @@VarShl$qqrv:near
  411.     call    @@VarShl$qqrv
  412. #endif
  413.   }
  414.   return *this;
  415. }
  416.  
  417. Variant& __fastcall Variant::operator >>=(const Variant&)
  418. {
  419.   asm
  420.   {
  421. #if defined(PRONTO_NAMESPACES)
  422.     extrn   @System@@VarShr$qqrv:near
  423.     call    @System@@VarShr$qqrv
  424. #else
  425.     extrn   @@VarShr$qqrv:near
  426.     call    @@VarShr$qqrv
  427. #endif
  428.   }
  429.   return *this;
  430. }
  431.  
  432. bool __fastcall Variant::operator ==(const Variant&) const
  433. {
  434.   asm
  435.   {
  436. #if defined(PRONTO_NAMESPACES)
  437.     extrn   @System@@VarCmp$qqrv:near
  438.     call    @System@@VarCmp$qqrv
  439. #else
  440.     extrn   @@VarCmp$qqrv:near
  441.     call    @@VarCmp$qqrv
  442. #endif
  443.     sete    al
  444.     and     eax, 1
  445.   }
  446. }
  447.  
  448. bool __fastcall Variant::operator !=(const Variant&) const
  449. {
  450.   asm
  451.   {
  452. #if defined(PRONTO_NAMESPACES)
  453.     extrn   @System@@VarCmp$qqrv:near
  454.     call    @System@@VarCmp$qqrv
  455. #else
  456.     extrn   @@VarCmp$qqrv:near
  457.     call    @@VarCmp$qqrv
  458. #endif
  459.     setne   al
  460.     and     eax, 1
  461.   }
  462. }
  463.  
  464. bool __fastcall Variant::operator <(const Variant&) const
  465. {
  466.   asm
  467.   {
  468. #if defined(PRONTO_NAMESPACES)
  469.     extrn   @System@@VarCmp$qqrv:near
  470.     call    @System@@VarCmp$qqrv
  471. #else
  472.     extrn   @@VarCmp$qqrv:near
  473.     call    @@VarCmp$qqrv
  474. #endif
  475.     setb    al
  476.     and     eax, 1
  477.   }
  478. }
  479.  
  480. bool __fastcall Variant::operator >(const Variant&) const
  481. {
  482.   asm
  483.   {
  484. #if defined(PRONTO_NAMESPACES)
  485.     extrn   @System@@VarCmp$qqrv:near
  486.     call    @System@@VarCmp$qqrv
  487. #else
  488.     extrn   @@VarCmp$qqrv:near
  489.     call    @@VarCmp$qqrv
  490. #endif
  491.     seta    al
  492.     and     eax, 1
  493.   }
  494. }
  495.  
  496. bool __fastcall Variant::operator <=(const Variant& rhs) const
  497. {
  498.   return !operator >(rhs);
  499. }
  500.  
  501. bool __fastcall Variant::operator >=(const Variant& rhs) const
  502. {
  503.   return !operator <(rhs);
  504. }
  505.  
  506. Variant __fastcall Variant::operator +(const Variant& rhs) const
  507. {
  508.   Variant tmp(*this);
  509.   Variant* ptmp = &tmp;
  510.   asm
  511.   {
  512. #if defined(PRONTO_NAMESPACES)
  513.     extrn   @System@@VarAdd$qqrv:near
  514. #else
  515.     extrn   @@VarAdd$qqrv:near
  516. #endif
  517.     mov     eax, ptmp
  518.     mov     edx, rhs
  519.  
  520. #if defined(PRONTO_NAMESPACES)
  521.     call    @System@@VarAdd$qqrv
  522. #else
  523.     call    @@VarAdd$qqrv
  524. #endif
  525.   }
  526.   return tmp;
  527. }
  528.  
  529. Variant __fastcall Variant::operator -(const Variant& rhs) const
  530. {
  531.   Variant tmp(*this);
  532.   Variant* ptmp = &tmp;
  533.   asm
  534.   {
  535. #if defined(PRONTO_NAMESPACES)
  536.     extrn   @System@@VarSub$qqrv:near
  537. #else
  538.     extrn   @@VarSub$qqrv:near
  539. #endif
  540.     mov     eax, ptmp
  541.     mov     edx, rhs
  542. #if defined(PRONTO_NAMESPACES)
  543.     call    @System@@VarSub$qqrv
  544. #else
  545.     call    @@VarSub$qqrv
  546. #endif
  547.   }
  548.   return tmp;
  549. }
  550.  
  551. Variant __fastcall Variant::operator *(const Variant& rhs) const
  552. {
  553.   Variant tmp(*this);
  554.   Variant* ptmp = &tmp;
  555.   asm
  556.   {
  557. #if defined(PRONTO_NAMESPACES)
  558.     extrn   @System@@VarMul$qqrv:near
  559. #else
  560.     extrn   @@VarMul$qqrv:near
  561. #endif
  562.     mov     eax, ptmp
  563.     mov     edx, rhs
  564. #if defined(PRONTO_NAMESPACES)
  565.     call    @System@@VarMul$qqrv
  566. #else
  567.     call    @@VarMul$qqrv
  568. #endif
  569.   }
  570.   return tmp;
  571. }
  572.  
  573. Variant __fastcall Variant::operator /(const Variant& rhs) const
  574. {
  575.   Variant tmp(*this);
  576.   Variant* ptmp = &tmp;
  577.   asm
  578.   {
  579. #if defined(PRONTO_NAMESPACES)
  580.     extrn   @System@@VarRDiv$qqrv:near
  581. #else
  582.     extrn   @@VarRDiv$qqrv:near
  583. #endif
  584.     mov     eax, ptmp
  585.     mov     edx, rhs
  586. #if defined(PRONTO_NAMESPACES)
  587.     call    @System@@VarRDiv$qqrv
  588. #else
  589.     call    @@VarRDiv$qqrv
  590. #endif
  591.   }
  592.   return tmp;
  593. }
  594.  
  595. Variant __fastcall Variant::operator %(const Variant& rhs) const
  596. {
  597.   Variant tmp(*this);
  598.   Variant* ptmp = &tmp;
  599.   asm
  600.   {
  601. #if defined(PRONTO_NAMESPACES)
  602.     extrn   @System@@VarMod$qqrv:near
  603. #else
  604.     extrn   @@VarMod$qqrv:near
  605. #endif
  606.     mov     eax, ptmp
  607.     mov     edx, rhs
  608. #if defined(PRONTO_NAMESPACES)
  609.     call    @System@@VarMod$qqrv
  610. #else
  611.     call    @@VarMod$qqrv
  612. #endif
  613.   }
  614.   return tmp;
  615. }
  616.  
  617. Variant __fastcall Variant::operator &(const Variant& rhs) const
  618. {
  619.   Variant tmp(*this);
  620.   Variant* ptmp = &tmp;
  621.   asm
  622.   {
  623. #if defined(PRONTO_NAMESPACES)
  624.     extrn   @System@@VarAnd$qqrv:near
  625. #else
  626.     extrn   @@VarAnd$qqrv:near
  627. #endif
  628.     mov     eax, ptmp
  629.     mov     edx, rhs
  630. #if defined(PRONTO_NAMESPACES)
  631.     call    @System@@VarAnd$qqrv
  632. #else
  633.     call    @@VarAnd$qqrv
  634. #endif
  635.   }
  636.   return tmp;
  637. }
  638.  
  639. Variant __fastcall Variant::operator |(const Variant& rhs) const
  640. {
  641.   Variant tmp(*this);
  642.   Variant* ptmp = &tmp;
  643.   asm
  644.   {
  645. #if defined(PRONTO_NAMESPACES)
  646.     extrn   @System@@VarOr$qqrv:near
  647. #else
  648.     extrn   @@VarOr$qqrv:near
  649. #endif
  650.     mov     eax, ptmp
  651.     mov     edx, rhs
  652. #if defined(PRONTO_NAMESPACES)
  653.     call    @System@@VarOr$qqrv
  654. #else
  655.     call    @@VarOr$qqrv
  656. #endif
  657.   }
  658.   return tmp;
  659. }
  660.  
  661. Variant __fastcall Variant::operator ^(const Variant& rhs) const
  662. {
  663.   Variant tmp(*this);
  664.   Variant* ptmp = &tmp;
  665.   asm
  666.   {
  667. #if defined(PRONTO_NAMESPACES)
  668.     extrn   @System@@VarXor$qqrv:near
  669. #else
  670.     extrn   @@VarXor$qqrv:near
  671. #endif
  672.     mov     eax, ptmp
  673.     mov     edx, rhs
  674. #if defined(PRONTO_NAMESPACES)
  675.     call    @System@@VarXor$qqrv
  676. #else
  677.     call    @@VarXor$qqrv
  678. #endif
  679.   }
  680.   return tmp;
  681. }
  682.  
  683. Variant __fastcall Variant::operator <<(const Variant& rhs) const
  684. {
  685.   Variant tmp(*this);
  686.   Variant* ptmp = &tmp;
  687.   asm
  688.   {
  689. #if defined(PRONTO_NAMESPACES)
  690.     extrn   @System@@VarShl$qqrv:near
  691. #else
  692.     extrn   @@VarShl$qqrv:near
  693. #endif
  694.     mov     eax, ptmp
  695.     mov     edx, rhs
  696. #if defined(PRONTO_NAMESPACES)
  697.     call    @System@@VarShl$qqrv
  698. #else
  699.     call    @@VarShl$qqrv
  700. #endif
  701.   }
  702.   return tmp;
  703. }
  704.  
  705. Variant __fastcall Variant::operator >>(const Variant& rhs) const
  706. {
  707.   Variant tmp(*this);
  708.   Variant* ptmp = &tmp;
  709.   asm
  710.   {
  711. #if defined(PRONTO_NAMESPACES)
  712.     extrn   @System@@VarShr$qqrv:near
  713. #else
  714.     extrn   @@VarShr$qqrv:near
  715. #endif
  716.     mov     eax, ptmp
  717.     mov     edx, rhs
  718. #if defined(PRONTO_NAMESPACES)
  719.     call    @System@@VarShr$qqrv
  720. #else
  721.     call    @@VarShr$qqrv
  722. #endif
  723.   }
  724.   return tmp;
  725. }
  726.  
  727. Variant __fastcall Variant::operator -() const
  728. {
  729.   Variant tmp(*this);
  730.   Variant* ptmp = &tmp;
  731.   asm
  732.   {
  733. #if defined(PRONTO_NAMESPACES)
  734.     extrn   @System@@VarNeg$qqrv:near
  735. #else
  736.     extrn   @@VarNeg$qqrv:near
  737. #endif
  738.     mov     eax, ptmp
  739. #if defined(PRONTO_NAMESPACES)
  740.     call    @System@@VarNeg$qqrv
  741. #else
  742.     call    @@VarNeg$qqrv
  743. #endif
  744.   }
  745.   return tmp;
  746. }
  747.  
  748. Variant __fastcall Variant::operator !() const
  749. {
  750.   Variant tmp(*this);
  751.   Variant* ptmp = &tmp;
  752.   asm
  753.   {
  754. #if defined(PRONTO_NAMESPACES)
  755.     extrn   @System@@VarNot$qqrv:near
  756. #else
  757.     extrn   @@VarNot$qqrv:near
  758. #endif
  759.     mov     eax, ptmp
  760. #if defined(PRONTO_NAMESPACES)
  761.     call    @System@@VarNot$qqrv
  762. #else
  763.     call    @@VarNot$qqrv
  764. #endif
  765.   }
  766.   return tmp;
  767. }
  768.  
  769. __fastcall Variant::operator short() const
  770. {
  771.   Variant tmp;
  772. #if defined(PRONTO_NAMESPACES)
  773.   System::VarCast(tmp, *this, varSmallint);
  774. #else
  775.   ::VarCast(tmp, *this, varSmallint);
  776. #endif
  777.   return tmp.VSmallint;
  778. }
  779.  
  780. __fastcall Variant::operator int() const
  781. {
  782.   Variant tmp;
  783. #if defined(PRONTO_NAMESPACES)
  784.   System::VarCast(tmp, *this, varInteger);
  785. #else
  786.   ::VarCast(tmp, *this, varInteger);
  787. #endif
  788.   return tmp.VInteger;
  789. }
  790.  
  791. __fastcall Variant::operator float() const
  792. {
  793.   Variant tmp;
  794. #if defined(PRONTO_NAMESPACES)
  795.   System::VarCast(tmp, *this, varSingle);
  796. #else
  797.   ::VarCast(tmp, *this, varSingle);
  798. #endif
  799.   return tmp.VSingle;
  800. }
  801.  
  802. __fastcall Variant::operator double() const
  803. {
  804.   Variant tmp;
  805. #if defined(PRONTO_NAMESPACES)
  806.   System::VarCast(tmp, *this, varDouble);
  807. #else
  808.   ::VarCast(tmp, *this, varDouble);
  809. #endif
  810.   return tmp.VDouble;
  811. }
  812.  
  813. __fastcall Variant::operator Currency() const
  814. {
  815.   Variant tmp;
  816. #if defined(PRONTO_NAMESPACES)
  817.   System::VarCast(tmp, *this, varCurrency);
  818. #else
  819.   ::VarCast(tmp, *this, varCurrency);
  820. #endif
  821.   return tmp.VCurrency;
  822. }
  823.  
  824. __fastcall Variant::operator TDateTime() const
  825. {
  826.   Variant tmp;
  827. #if defined(PRONTO_NAMESPACES)
  828.   System::VarCast(tmp, *this, varDate);
  829. #else
  830.   ::VarCast(tmp, *this, varDate);
  831. #endif
  832.   return tmp.VDate;
  833. }
  834.  
  835. __fastcall Variant::operator bool() const
  836. {
  837.   Variant tmp;
  838. #if defined(PRONTO_NAMESPACES)
  839.   System::VarCast(tmp, *this, varBoolean);
  840. #else
  841.   ::VarCast(tmp, *this, varBoolean);
  842. #endif
  843.   return (bool)tmp.VBoolean;
  844. }
  845.  
  846. __fastcall Variant::operator WordBool() const
  847. {
  848.   Variant tmp;
  849. #if defined(PRONTO_NAMESPACES)
  850.   System::VarCast(tmp, *this, varBoolean);
  851. #else
  852.   ::VarCast(tmp, *this, varBoolean);
  853. #endif
  854.   return tmp.VBoolean;
  855. }
  856.  
  857. __fastcall Variant::operator Byte() const
  858. {
  859.   Variant tmp;
  860. #if defined(PRONTO_NAMESPACES)
  861.   System::VarCast(tmp, *this, varByte);
  862. #else
  863.   ::VarCast(tmp, *this, varByte);
  864. #endif
  865.   return tmp.VByte;
  866. }
  867.  
  868. __fastcall Variant::operator AnsiString() const
  869. {
  870.   Variant tmp;
  871. #if defined(PRONTO_NAMESPACES)
  872.   System::VarCast(tmp, *this, varString);
  873. #else
  874.   ::VarCast(tmp, *this, varString);
  875. #endif
  876.   return AnsiString((AnsiString&)(tmp.VString));
  877. }
  878.  
  879. __fastcall Variant::operator Ole2::IDispatch*()
  880. {
  881.   Variant tmp;
  882. #if defined(PRONTO_NAMESPACES)
  883.   System::VarCast(tmp, *this, varDispatch);
  884. #else
  885.   ::VarCast(tmp, *this, varDispatch);
  886. #endif
  887.   if (tmp.VDispatch)
  888.     tmp.VDispatch->AddRef();
  889.   return tmp.VDispatch;
  890. }
  891.  
  892. __fastcall Variant::operator Ole2::IUnknown*()
  893. {
  894.   Variant tmp;
  895. #if defined(PRONTO_NAMESPACES)
  896.   System::VarCast(tmp, *this, varUnknown);
  897. #else
  898.   ::VarCast(tmp, *this, varUnknown);
  899. #endif
  900.   if (tmp.VUnknown)
  901.     tmp.VUnknown->AddRef();
  902.   return tmp.VUnknown;
  903. }
  904.  
  905. // by ref conversion operators
  906. __fastcall Variant::operator short*()
  907. {
  908.   if (VType == (varSmallint | varByRef))
  909.     return reinterpret_cast<short*>(VPointer);
  910.   else if (VType == varSmallint)
  911.     return &VSmallint;
  912.   else
  913.     throw new EVariantError(sOpShortPtr);
  914. }
  915.  
  916. __fastcall Variant::operator int*()
  917. {
  918.   if (VType == (varInteger | varByRef))
  919.     return reinterpret_cast<int*>(VPointer);
  920.   else if (VType == varInteger)
  921.     return &VInteger;
  922.   else
  923.     throw new EVariantError(sOpIntPtr);
  924. }
  925.  
  926. __fastcall Variant::operator float*()
  927. {
  928.   if (VType == (varSingle | varByRef))
  929.     return reinterpret_cast<float*>(VPointer);
  930.   else if (VType == varSingle)
  931.     return &VSingle;
  932.   else
  933.     throw new EVariantError(sOpFloatPtr);
  934. }
  935.  
  936. __fastcall Variant::operator double*()
  937. {
  938.   if (VType == (varDouble | varByRef))
  939.     return reinterpret_cast<double*>(VPointer);
  940.   else if (VType == varDouble)
  941.     return &VDouble;
  942.   else
  943.     throw new EVariantError(sOpDoublePtr);
  944. }
  945.  
  946. __fastcall Variant::operator Currency*()
  947. {
  948.   if (VType == (varCurrency | varByRef))
  949.     return reinterpret_cast<Currency*>(VPointer);
  950.   else if (VType == varCurrency)
  951.     return reinterpret_cast<Currency*>(&VCurrency);
  952.   else
  953.     throw new EVariantError(sOpCurrencyPtr);
  954. }
  955.  
  956. __fastcall Variant::operator TDateTime*()
  957. {
  958.   if (VType == (varDate | varByRef))
  959.     return reinterpret_cast<TDateTime*>(VPointer);
  960.   else if (VType == varDate)
  961.     return reinterpret_cast<TDateTime*>(&VDate);
  962.   else
  963.     throw new EVariantError(sOpTDateTimePtr);
  964. }
  965.  
  966. __fastcall Variant::operator WordBool*()
  967. {
  968.   if (VType == (varBoolean | varByRef))
  969.     return reinterpret_cast<WordBool*>(VPointer);
  970.   else
  971.     throw new EVariantError(sOpBoolPtr);
  972. }
  973.  
  974. __fastcall Variant::operator Byte*()
  975. {
  976.   if (VType == (varByte | varByRef))
  977.     return reinterpret_cast<Byte*>(VPointer);
  978.   else if (VType == varByte)
  979.     return &VByte;
  980.   else
  981.     throw new EVariantError(sOpBytePtr);
  982. }
  983.  
  984. __fastcall Variant::operator wchar_t**()
  985. {
  986.   if (VType == (varOleStr | varByRef))
  987.     return reinterpret_cast<wchar_t**>(VPointer);
  988.   else if (VType == varOleStr)
  989.     return &VOleStr;
  990.   else
  991.     throw new EVariantError(sOpWCharTPtr);
  992. }
  993.  
  994. void __fastcall Variant::SetError(const int err)
  995. {
  996.   Clear();
  997.   VType = varError;
  998.   VError = err;
  999. }
  1000.  
  1001. int __fastcall Variant::GetError() const
  1002. {
  1003.   Variant tmp;
  1004. #if defined(PRONTO_NAMESPACES)
  1005.   System::VarCast(tmp, *this, varError);
  1006. #else
  1007.   ::VarCast(tmp, *this, varError);
  1008. #endif
  1009.   return tmp.VError;
  1010. }
  1011.  
  1012. Variant& __fastcall Variant::ChangeType(int varType)
  1013. {
  1014.   Variant tmp;
  1015. #if defined(PRONTO_NAMESPACES)
  1016.   System::VarCast(tmp, *this, varType);
  1017. #else
  1018.   ::VarCast(tmp, *this, varType);
  1019. #endif
  1020.   return operator =(tmp);
  1021. }
  1022.  
  1023. Variant __fastcall Variant::AsType(int varType) const
  1024. {
  1025.   Variant tmp;
  1026. #if defined(PRONTO_NAMESPACES)
  1027.   System::VarCast(tmp, *this, varType);
  1028. #else
  1029.   ::VarCast(tmp, *this, varType);
  1030. #endif
  1031.   return tmp;
  1032. }
  1033.  
  1034. void __fastcall Variant::Clear()
  1035. {
  1036. #if defined(PRONTO_NAMESPACES)
  1037.   System::VarClear(*this);
  1038. #else
  1039.   ::VarClear(*this);
  1040. #endif
  1041. }
  1042.  
  1043. int __fastcall Variant::Type() const
  1044. {
  1045. #if defined(PRONTO_NAMESPACES)
  1046.   return System::VarType(*this);
  1047. #else
  1048.   return ::VarType(*this);
  1049. #endif
  1050. }
  1051.  
  1052. bool __fastcall Variant::IsNull() const
  1053. {
  1054. #if defined(PRONTO_NAMESPACES)
  1055.   return System::VarIsNull(*this);
  1056. #else
  1057.   return ::VarIsNull(*this);
  1058. #endif
  1059. }
  1060.  
  1061. bool __fastcall Variant::IsEmpty() const
  1062. {
  1063. #if defined(PRONTO_NAMESPACES)
  1064.   return System::VarIsEmpty(*this);
  1065. #else
  1066.   return ::VarIsEmpty(*this);
  1067. #endif
  1068. }
  1069.  
  1070. bool __fastcall Variant::IsArray() const
  1071. {
  1072. #if defined(PRONTO_NAMESPACES)
  1073.   return System::VarIsArray(*this);
  1074. #else
  1075.   return ::VarIsArray(*this);
  1076. #endif
  1077. }
  1078.  
  1079. int __fastcall Variant::ArrayDimCount() const
  1080. {
  1081. #if defined(PRONTO_NAMESPACES)
  1082.   return System::VarArrayDimCount(*this);
  1083. #else
  1084.   return ::VarArrayDimCount(*this);
  1085. #endif
  1086. }
  1087.  
  1088. int __fastcall Variant::ArrayLowBound(const int dim) const
  1089. {
  1090. #if defined(PRONTO_NAMESPACES)
  1091.   return System::VarArrayLowBound(*this, dim);
  1092. #else
  1093.   return ::VarArrayLowBound(*this, dim);
  1094. #endif
  1095. }
  1096.  
  1097. int __fastcall Variant::ArrayHighBound(const int dim) const
  1098. {
  1099. #if defined(PRONTO_NAMESPACES)
  1100.   return System::VarArrayHighBound(*this, dim);
  1101. #else
  1102.   return ::VarArrayHighBound(*this, dim);
  1103. #endif
  1104. }
  1105.  
  1106. void __fastcall Variant::ArrayRedim(int highBound)
  1107. {
  1108. #if defined(PRONTO_NAMESPACES)
  1109.   System::VarArrayRedim(*this, highBound);
  1110. #else
  1111.   ::VarArrayRedim(*this, highBound);
  1112. #endif
  1113. }
  1114.  
  1115. Pointer __fastcall Variant::ArrayLock()
  1116. {
  1117. #if defined(PRONTO_NAMESPACES)
  1118.   return System::VarArrayLock(*this);
  1119. #else
  1120.   return ::VarArrayLock(*this);
  1121. #endif
  1122. }
  1123.  
  1124. void    __fastcall Variant::ArrayUnlock()
  1125. {
  1126. #if defined(PRONTO_NAMESPACES)
  1127.   System::VarArrayUnlock(*this);
  1128. #else
  1129.   ::VarArrayUnlock(*this);
  1130. #endif
  1131. }
  1132.  
  1133. Variant& __fastcall Variant::operator [](const int idx)
  1134. {
  1135.   //!JK only use this function for arrays of type Variant!
  1136.   if (!IsArray() || idx < ArrayLowBound() || idx > ArrayHighBound())
  1137.     throw new EVariantError(sVarRangeArray);
  1138.  
  1139.   Variant* array((Variant*)ArrayLock());
  1140.   Variant* v(array + idx);
  1141.   ArrayUnlock();
  1142.   return *v;
  1143. }
  1144.  
  1145. Variant __fastcall Variant::GetElement(const int i1) const
  1146. {
  1147.   Variant tmp;
  1148.   Variant* ptmp = &tmp;
  1149.   asm {
  1150. #if defined(PRONTO_NAMESPACES)
  1151.     extrn @System@@VarArrayGet$qr14System@Variantii:near
  1152. #else
  1153.     extrn @@VarArrayGet$qr7Variantii:near
  1154. #endif
  1155.     push i1
  1156.     push 1
  1157.     mov eax, this
  1158.     push eax
  1159.     mov eax, ptmp
  1160.     push eax
  1161. #if defined(PRONTO_NAMESPACES)
  1162.     call    @System@@VarArrayGet$qr14System@Variantii
  1163. #else
  1164.     call    @@VarArrayGet$qr7Variantii
  1165. #endif
  1166.     add esp, 0x10
  1167.   }
  1168.   return tmp;
  1169. }
  1170.  
  1171. Variant __fastcall Variant::GetElement(const int i1, const int i2) const
  1172. {
  1173.   Variant tmp;
  1174.   Variant* ptmp = &tmp;
  1175.   asm {
  1176. #if defined(PRONTO_NAMESPACES)
  1177.     extrn @System@@VarArrayGet$qr14System@Variantii:near
  1178. #else
  1179.     extrn @@VarArrayGet$qr7Variantii:near
  1180. #endif
  1181.     push i2
  1182.     push i1
  1183.     push 2
  1184.     mov eax, this
  1185.     push eax
  1186.     mov eax, ptmp
  1187.     push eax
  1188. #if defined(PRONTO_NAMESPACES)
  1189.     call    @System@@VarArrayGet$qr14System@Variantii
  1190. #else
  1191.     call    @@VarArrayGet$qr7Variantii
  1192. #endif
  1193.     add esp, 0x14
  1194.   }
  1195.   return tmp;
  1196. }
  1197.  
  1198. Variant __fastcall Variant::GetElement(const int i1, const int i2,
  1199.   const int i3) const
  1200. {
  1201.   Variant tmp;
  1202.   Variant* ptmp = &tmp;
  1203.   asm {
  1204. #if defined(PRONTO_NAMESPACES)
  1205.     extrn @System@@VarArrayGet$qr14System@Variantii:near
  1206. #else
  1207.     extrn @@VarArrayGet$qr7Variantii:near
  1208. #endif
  1209.     push i3
  1210.     push i2
  1211.     push i1
  1212.     push 3
  1213.     mov eax, this
  1214.     push eax
  1215.     mov eax, ptmp
  1216.     push eax
  1217. #if defined(PRONTO_NAMESPACES)
  1218.     call    @System@@VarArrayGet$qr14System@Variantii
  1219. #else
  1220.     call    @@VarArrayGet$qr7Variantii
  1221. #endif
  1222.     add esp, 0x18
  1223.   }
  1224.   return tmp;
  1225. }
  1226.  
  1227. Variant __fastcall Variant::GetElement(const int i1, const int i2,
  1228.   const int i3, const int i4) const
  1229. {
  1230.   Variant tmp;
  1231.   Variant* ptmp = &tmp;
  1232.   asm {
  1233. #if defined(PRONTO_NAMESPACES)
  1234.     extrn @System@@VarArrayGet$qr14System@Variantii:near
  1235. #else
  1236.     extrn @@VarArrayGet$qr7Variantii:near
  1237. #endif
  1238.     push i4
  1239.     push i3
  1240.     push i2
  1241.     push i1
  1242.     push 4
  1243.     mov eax, this
  1244.     push eax
  1245.     mov eax, ptmp
  1246.     push eax
  1247. #if defined(PRONTO_NAMESPACES)
  1248.     call    @System@@VarArrayGet$qr14System@Variantii
  1249. #else
  1250.     call    @@VarArrayGet$qr7Variantii
  1251. #endif
  1252.     add esp, 0x1C
  1253.   }
  1254.   return tmp;
  1255. }
  1256.  
  1257. Variant __fastcall Variant::GetElement(const int i1, const int i2,
  1258.   const int i3, const int i4, const int i5) const
  1259. {
  1260.   Variant tmp;
  1261.   Variant* ptmp = &tmp;
  1262.   asm {
  1263. #if defined(PRONTO_NAMESPACES)
  1264.     extrn @System@@VarArrayGet$qr14System@Variantii:near
  1265. #else
  1266.     extrn @@VarArrayGet$qr7Variantii:near
  1267. #endif
  1268.     push i5
  1269.     push i4
  1270.     push i3
  1271.     push i2
  1272.     push i1
  1273.     push 5
  1274.     mov eax, this
  1275.     push eax
  1276.     mov eax, ptmp
  1277.     push eax
  1278. #if defined(PRONTO_NAMESPACES)
  1279.     call    @System@@VarArrayGet$qr14System@Variantii
  1280. #else
  1281.     call    @@VarArrayGet$qr7Variantii
  1282. #endif
  1283.     add esp, 0x20
  1284.   }
  1285.   return tmp;
  1286. }
  1287.  
  1288. void __fastcall Variant::PutElement(const Variant& data, const int i1)
  1289. {
  1290.   asm {
  1291. #if defined(PRONTO_NAMESPACES)
  1292.     extrn   @System@@VarArrayPut$qr14System@Variantrx14System@Variantii:near
  1293. #else
  1294.     extrn   @@VarArrayPut$qr7Variantrx7Variantii:near
  1295. #endif
  1296.     push i1
  1297.     push 1
  1298.     mov eax, data
  1299.     push eax
  1300.     mov eax, this
  1301.     push eax
  1302. #if defined(PRONTO_NAMESPACES)
  1303.     call   @System@@VarArrayPut$qr14System@Variantrx14System@Variantii
  1304. #else
  1305.     call   @@VarArrayPut$qr7Variantrx7Variantii
  1306. #endif
  1307.     add esp, 0x10
  1308.   }
  1309. }
  1310.  
  1311. void __fastcall Variant::PutElement(const Variant& data, const int i1,
  1312.   const int i2)
  1313. {
  1314.   asm {
  1315. #if defined(PRONTO_NAMESPACES)
  1316.     extrn   @System@@VarArrayPut$qr14System@Variantrx14System@Variantii:near
  1317. #else
  1318.     extrn   @@VarArrayPut$qr7Variantrx7Variantii:near
  1319. #endif
  1320.     push i2
  1321.     push i1
  1322.     push 2
  1323.     mov eax, data
  1324.     push eax
  1325.     mov eax, this
  1326.     push eax
  1327. #if defined(PRONTO_NAMESPACES)
  1328.     call   @System@@VarArrayPut$qr14System@Variantrx14System@Variantii
  1329. #else
  1330.     call   @@VarArrayPut$qr7Variantrx7Variantii
  1331. #endif
  1332.     add esp, 0x14
  1333.   }
  1334. }
  1335.  
  1336. void __fastcall Variant::PutElement(const Variant& data, const int i1,
  1337.   const int i2, const int i3)
  1338. {
  1339.   asm {
  1340. #if defined(PRONTO_NAMESPACES)
  1341.     extrn   @System@@VarArrayPut$qr14System@Variantrx14System@Variantii:near
  1342. #else
  1343.     extrn   @@VarArrayPut$qr7Variantrx7Variantii:near
  1344. #endif
  1345.     push i3
  1346.     push i2
  1347.     push i1
  1348.     push 3
  1349.     mov eax, data
  1350.     push eax
  1351.     mov eax, this
  1352.     push eax
  1353. #if defined(PRONTO_NAMESPACES)
  1354.     call   @System@@VarArrayPut$qr14System@Variantrx14System@Variantii
  1355. #else
  1356.     call   @@VarArrayPut$qr7Variantrx7Variantii
  1357. #endif
  1358.     add esp, 0x18
  1359.   }
  1360. }
  1361.  
  1362. void __fastcall Variant::PutElement(const Variant& data, const int i1,
  1363.   const int i2, const int i3, const int i4)
  1364. {
  1365.   asm {
  1366. #if defined(PRONTO_NAMESPACES)
  1367.     extrn   @System@@VarArrayPut$qr14System@Variantrx14System@Variantii:near
  1368. #else
  1369.     extrn   @@VarArrayPut$qr7Variantrx7Variantii:near
  1370. #endif
  1371.     push i4
  1372.     push i3
  1373.     push i2
  1374.     push i1
  1375.     push 4
  1376.     mov eax, data
  1377.     push eax
  1378.     mov eax, this
  1379.     push eax
  1380. #if defined(PRONTO_NAMESPACES)
  1381.     call   @System@@VarArrayPut$qr14System@Variantrx14System@Variantii
  1382. #else
  1383.     call   @@VarArrayPut$qr7Variantrx7Variantii
  1384. #endif
  1385.     add esp, 0x1C
  1386.   }
  1387. }
  1388.  
  1389. void __fastcall Variant::PutElement(const Variant& data, const int i1,
  1390.   const int i2, const int i3, const int i4, const int i5)
  1391. {
  1392.   asm {
  1393. #if defined(PRONTO_NAMESPACES)
  1394.     extrn   @System@@VarArrayPut$qr14System@Variantrx14System@Variantii:near
  1395. #else
  1396.     extrn   @@VarArrayPut$qr7Variantrx7Variantii:near
  1397. #endif
  1398.     push i5
  1399.     push i4
  1400.     push i3
  1401.     push i2
  1402.     push i1
  1403.     push 5
  1404.     mov eax, data
  1405.     push eax
  1406.     mov eax, this
  1407.     push eax
  1408. #if defined(PRONTO_NAMESPACES)
  1409.     call   @System@@VarArrayPut$qr14System@Variantrx14System@Variantii
  1410. #else
  1411.     call   @@VarArrayPut$qr7Variantrx7Variantii
  1412. #endif
  1413.     add esp, 0x20
  1414.   }
  1415. }
  1416.  
  1417. Variant __fastcall Variant::Exec(AutoCmd& cmd, Integer lcid)
  1418. {
  1419.   //Result
  1420.   Variant tmp;
  1421.   Variant* ptmp = 0;
  1422.  
  1423.   if (cmd.RequestResult())
  1424.     ptmp = &tmp;
  1425.  
  1426.   //construct a call descriptor
  1427.   TCallDesc callDesc;
  1428.   TCallDesc* pcallDesc = &callDesc;
  1429.  
  1430.   // set calltype, argcount, named arg count
  1431.   callDesc.CallType = cmd.GetCallType();
  1432.   callDesc.ArgCount = cmd.GetArgCount();
  1433.   callDesc.NamedArgCount = cmd.GetNamedArgCount();
  1434.   callDesc.Locale = lcid;
  1435.  
  1436.   // fill in arg types for named args
  1437.   for (Byte i = 0; i < callDesc.NamedArgCount; i++)
  1438.   {
  1439.     int argType = cmd.GetNamedArgType(i);
  1440.     if (argType == varString)
  1441.       callDesc.ArgTypes[i] = varStrArg;
  1442.     else if (argType == (varString | varByRef))
  1443.       callDesc.ArgTypes[i] = varStrArg + 128;
  1444.     else
  1445.     {
  1446.       callDesc.ArgTypes[i] = (Byte)(argType & varTypeMask);
  1447.       callDesc.ArgTypes[i] += (Byte)((argType & varByRef)? 128: 0);
  1448.     }
  1449.   }
  1450.  
  1451.   // fill in arg types for un-named args
  1452.   for (Byte i = callDesc.NamedArgCount; i < callDesc.ArgCount; i++)
  1453.   {
  1454.     int argType = cmd.GetArgType((Byte)(i-callDesc.NamedArgCount));
  1455.     if (argType == varString)
  1456.       callDesc.ArgTypes[i] = varStrArg;
  1457.     else if (argType == (varString | varByRef))
  1458.       callDesc.ArgTypes[i] = varStrArg + 128;
  1459.     else
  1460.     {
  1461.       callDesc.ArgTypes[i] = (Byte)(argType & varTypeMask);
  1462.       callDesc.ArgTypes[i] += (Byte)((argType & varByRef)? 128: 0);
  1463.     }
  1464.   }
  1465.  
  1466.   // get ptr that points after all argtypes
  1467.   char* p = (char*) &callDesc.ArgTypes[callDesc.ArgCount];
  1468.  
  1469.   // fill in the name of the cmd
  1470.   strcpy(p, (char*)cmd.GetName().c_str());
  1471.  
  1472.   // fill in names of named args
  1473.   for (Byte i = 0; i < callDesc.NamedArgCount; i++)
  1474.     strcat(p, (char*)cmd.GetNamedParmName(i).c_str());
  1475.  
  1476.   // fill an array of values/addresses of named args (makes asm easier)
  1477.   void* namedParms[MaxDispArgs*2];
  1478.   void* namedParmsPtr = &namedParms;
  1479.   Byte namedCursor = 0;
  1480.   for (Byte i = 0; i < callDesc.NamedArgCount; i++)
  1481.   {
  1482.     Variant* v = & cmd.GetNamedParm(i);
  1483.     int argType = cmd.GetNamedArgType(i) & varTypeMask;
  1484.     bool byRef = cmd.GetNamedArgType(i) & varByRef;
  1485.     if (!byRef)
  1486.     {
  1487.       switch (argType)
  1488.       {
  1489.         case varString:
  1490.           namedParms[namedCursor++] = cmd.GetNamedStringArg(i).c_str();
  1491.           break;
  1492.         case varDouble:
  1493.         case varDate:
  1494.         case varCurrency:
  1495.           namedParms[namedCursor++] = reinterpret_cast<void*>(*((&v->VInteger) + 1)); //half
  1496.           namedParms[namedCursor++] = reinterpret_cast<void*>(v->VInteger);  // other half
  1497.           break;
  1498.         case varSingle:
  1499.         case varDispatch:
  1500.         case varInteger:
  1501.         case varBoolean:
  1502.         case varUnknown:
  1503.           namedParms[namedCursor++] = reinterpret_cast<void*>(v->VInteger);  // pick 1 (union)
  1504.           break;
  1505.         case varSmallint:
  1506.           namedParms[namedCursor++] = reinterpret_cast<void*>((int)v->VSmallint);
  1507.           break;
  1508.         case varByte:
  1509.           namedParms[namedCursor++] = reinterpret_cast<void*>((int)v->VByte);
  1510.           break;
  1511.         case varVariant:
  1512.           namedParms[namedCursor++] = v;
  1513.           break;
  1514.       }
  1515.     }
  1516.     else // byRef
  1517.     {
  1518.       if (argType == varString)
  1519.         namedParms[namedCursor++] = cmd.GetNamedStringPtr(i);
  1520.       else if (argType == varVariant)
  1521.         namedParms[namedCursor++] = v;
  1522.       else
  1523.         namedParms[namedCursor++] = v->VPointer;
  1524.     }
  1525.   }
  1526.   // fill an array of values/addresses of un-named args (makes asm easier)
  1527.   void* parms[MaxDispArgs*2];
  1528.   void* parmsPtr = &parms;
  1529.   Byte cursor = 0;
  1530.   for (Byte i = 0; i < callDesc.ArgCount - callDesc.NamedArgCount; i++)
  1531.   {
  1532.     Variant* v = & cmd.GetParm(i);
  1533.     int argType = cmd.GetArgType(i) & varTypeMask;
  1534.     bool byRef = cmd.GetArgType(i) & varByRef;
  1535.     if (!byRef)
  1536.     {
  1537.       switch (argType)
  1538.       {
  1539.         case varString:
  1540.           parms[cursor++] = cmd.GetStringArg(i).c_str();
  1541.           break;
  1542.         case varDouble:
  1543.         case varDate:
  1544.         case varCurrency:
  1545.           parms[cursor++] = reinterpret_cast<void*>(*((&v->VInteger) + 1)); //half
  1546.           parms[cursor++] = reinterpret_cast<void*>(v->VInteger);  // other half
  1547.           break;
  1548.         case varSingle:
  1549.         case varDispatch:
  1550.         case varInteger:
  1551.         case varBoolean:
  1552.         case varUnknown:
  1553.           parms[cursor++] = reinterpret_cast<void*>(v->VInteger);  // pick 1 (union)
  1554.           break;
  1555.         case varSmallint:
  1556.           parms[cursor++] = reinterpret_cast<void*>((int)v->VSmallint);
  1557.           break;
  1558.         case varByte:
  1559.           parms[cursor++] = reinterpret_cast<void*>((int)v->VByte);
  1560.           break;
  1561.         case varVariant:
  1562.           parms[cursor++] = v;
  1563.           break;
  1564.       }
  1565.     }
  1566.     else // byRef
  1567.     {
  1568.       if (argType == varString)
  1569.         parms[cursor++] = cmd.GetStringPtr(i);
  1570.       else if (argType == varVariant)
  1571.         parms[cursor++] = v;
  1572.       else
  1573.         parms[cursor++] = v->VPointer;
  1574.     }
  1575.   }
  1576.   asm
  1577.   {
  1578. #if defined(PRONTO_NAMESPACES)
  1579.     extrn   @System@@DispInvoke$qv:near
  1580. #else
  1581.     extrn   @@DispInvoke$qv:near
  1582. #endif
  1583.     xor     edx, edx
  1584.     mov     dl, cursor
  1585.     dec     edx
  1586.     imul    edx, 4
  1587.     add     edx, parmsPtr
  1588.     mov     cl, cursor
  1589. @@0:
  1590.     dec     cl
  1591.     test    cl,  cl
  1592.     jl      @@1
  1593.     mov     eax, [edx]
  1594.     push    eax
  1595.     sub     edx, 4
  1596.     jmp     @@0
  1597.  
  1598. @@1:
  1599.     xor     edx, edx
  1600.     mov     dl, namedCursor
  1601.     dec     edx
  1602.     imul    edx, 4
  1603.     add     edx, namedParmsPtr
  1604. @@2:
  1605.     dec     cl
  1606.     test    cl,  cl
  1607.     jl      @@3
  1608.     mov     eax, [edx]
  1609.     push    eax
  1610.     sub     edx, 4
  1611.     jmp     @@2
  1612. @@3:
  1613.  
  1614.     push    pcallDesc
  1615.     push    this
  1616.     push    ptmp
  1617.  
  1618. #if defined(PRONTO_NAMESPACES)
  1619.     call    @System@@DispInvoke$qv
  1620. #else
  1621.     call    @@DispInvoke$qv
  1622. #endif
  1623.  
  1624.     xor     ecx, ecx
  1625.     mov     cl, cursor
  1626.     add     cl, namedCursor
  1627.     imul    ecx, 4
  1628.     add     ecx, 12
  1629.     add     esp, ecx
  1630.   }
  1631.  
  1632.   // if no result is returned, return a true
  1633.   if (!cmd.RequestResult())
  1634.     tmp = true;
  1635.  
  1636.   return tmp;
  1637. }
  1638.  
  1639. // alternate syntax automation stuff
  1640. void Variant::OleProcedure(const String& name, Variant& v0,
  1641.       Variant& v1, Variant& v2, Variant& v3,
  1642.       Variant& v4, Variant& v5, Variant& v6,
  1643.       Variant& v7, Variant& v8, Variant& v9)
  1644. {
  1645.   Procedure p(name);
  1646.  
  1647.   if (v0.Type() != varEmpty)
  1648.   {
  1649.     p << v0;
  1650.     if (v1.Type() != varEmpty)
  1651.     {
  1652.       p << v1;
  1653.       if (v2.Type() != varEmpty)
  1654.       {
  1655.         p << v2;
  1656.         if (v3.Type() != varEmpty)
  1657.         {
  1658.           p << v3;
  1659.           if (v4.Type() != varEmpty)
  1660.           {
  1661.             p << v4;
  1662.             if (v5.Type() != varEmpty)
  1663.             {
  1664.               p << v5;
  1665.               if (v6.Type() != varEmpty)
  1666.               {
  1667.                 p << v6;
  1668.                 if (v7.Type() != varEmpty)
  1669.                 {
  1670.                   p << v7;
  1671.                   if (v8.Type() != varEmpty)
  1672.                   {
  1673.                     p << v8;
  1674.                     if (v9.Type() != varEmpty)
  1675.                       p << v9;
  1676.                   }
  1677.                 }
  1678.               }
  1679.             }
  1680.           }
  1681.         }
  1682.       }
  1683.     }
  1684.   }
  1685.   Exec(p);
  1686. }
  1687.  
  1688. Variant Variant::OleFunction(const String& name, Variant& v0,
  1689.       Variant& v1, Variant& v2, Variant& v3,
  1690.       Variant& v4, Variant& v5, Variant& v6,
  1691.       Variant& v7, Variant& v8, Variant& v9)
  1692. {
  1693.   Function p(name);
  1694.  
  1695.   if (v0.Type() != varEmpty)
  1696.   {
  1697.     p << v0;
  1698.     if (v1.Type() != varEmpty)
  1699.     {
  1700.       p << v1;
  1701.       if (v2.Type() != varEmpty)
  1702.       {
  1703.         p << v2;
  1704.         if (v3.Type() != varEmpty)
  1705.         {
  1706.           p << v3;
  1707.           if (v4.Type() != varEmpty)
  1708.           {
  1709.             p << v4;
  1710.             if (v5.Type() != varEmpty)
  1711.             {
  1712.               p << v5;
  1713.               if (v6.Type() != varEmpty)
  1714.               {
  1715.                 p << v6;
  1716.                 if (v7.Type() != varEmpty)
  1717.                 {
  1718.                   p << v7;
  1719.                   if (v8.Type() != varEmpty)
  1720.                   {
  1721.                     p << v8;
  1722.                     if (v9.Type() != varEmpty)
  1723.                       p << v9;
  1724.                   }
  1725.                 }
  1726.               }
  1727.             }
  1728.           }
  1729.         }
  1730.       }
  1731.     }
  1732.   }
  1733.   return Exec(p);
  1734. }
  1735.  
  1736. Variant Variant::OlePropertyGet(const String& name, Variant& v0,
  1737.       Variant& v1, Variant& v2, Variant& v3,
  1738.       Variant& v4, Variant& v5, Variant& v6,
  1739.       Variant& v7, Variant& v8, Variant& v9)
  1740. {
  1741.   PropertyGet p(name);
  1742.  
  1743.   if (v0.Type() != varEmpty)
  1744.   {
  1745.     p << v0;
  1746.     if (v1.Type() != varEmpty)
  1747.     {
  1748.       p << v1;
  1749.       if (v2.Type() != varEmpty)
  1750.       {
  1751.         p << v2;
  1752.         if (v3.Type() != varEmpty)
  1753.         {
  1754.           p << v3;
  1755.           if (v4.Type() != varEmpty)
  1756.           {
  1757.             p << v4;
  1758.             if (v5.Type() != varEmpty)
  1759.             {
  1760.               p << v5;
  1761.               if (v6.Type() != varEmpty)
  1762.               {
  1763.                 p << v6;
  1764.                 if (v7.Type() != varEmpty)
  1765.                 {
  1766.                   p << v7;
  1767.                   if (v8.Type() != varEmpty)
  1768.                   {
  1769.                     p << v8;
  1770.                     if (v9.Type() != varEmpty)
  1771.                       p << v9;
  1772.                   }
  1773.                 }
  1774.               }
  1775.             }
  1776.           }
  1777.         }
  1778.       }
  1779.     }
  1780.   }
  1781.   return Exec(p);
  1782. }
  1783.  
  1784. void Variant::OlePropertySet(const String& name, Variant& v0,
  1785.       Variant& v1, Variant& v2, Variant& v3,
  1786.       Variant& v4, Variant& v5, Variant& v6,
  1787.       Variant& v7, Variant& v8, Variant& v9)
  1788. {
  1789.   PropertySet p(name);
  1790.  
  1791.   if (v0.Type() != varEmpty)
  1792.   {
  1793.     p << v0;
  1794.     if (v1.Type() != varEmpty)
  1795.     {
  1796.       p << v1;
  1797.       if (v2.Type() != varEmpty)
  1798.       {
  1799.         p << v2;
  1800.         if (v3.Type() != varEmpty)
  1801.         {
  1802.           p << v3;
  1803.           if (v4.Type() != varEmpty)
  1804.           {
  1805.             p << v4;
  1806.             if (v5.Type() != varEmpty)
  1807.             {
  1808.               p << v5;
  1809.               if (v6.Type() != varEmpty)
  1810.               {
  1811.                 p << v6;
  1812.                 if (v7.Type() != varEmpty)
  1813.                 {
  1814.                   p << v7;
  1815.                   if (v8.Type() != varEmpty)
  1816.                   {
  1817.                     p << v8;
  1818.                     if (v9.Type() != varEmpty)
  1819.                       p << v9;
  1820.                   }
  1821.                 }
  1822.               }
  1823.             }
  1824.           }
  1825.         }
  1826.       }
  1827.     }
  1828.   }
  1829.   Exec(p);
  1830. }
  1831. // end of alternate syntax automation stuff
  1832.  
  1833. ostream& operator <<(ostream& os, const Variant& arg)
  1834. {
  1835.   switch (arg.VType)
  1836.   {
  1837.     case varEmpty:
  1838.       os << "varEmpty";
  1839.       break;
  1840.     case varNull:
  1841.       os << "varNull";
  1842.       break;
  1843.     case varSmallint:
  1844.       os << "varSmallint: " << arg.VSmallint;
  1845.       break;
  1846.     case varInteger:
  1847.       os << "varInteger: " << arg.VInteger;
  1848.       break;
  1849.     case varSingle:
  1850.       os << "varSingle: " << arg.VSingle;
  1851.       break;
  1852.     case varDouble:
  1853.       os << "varDouble: " << arg.VDouble;
  1854.       break;
  1855.     case varCurrency:
  1856.       os << "varCurrency: " << arg.VCurrency;
  1857.       break;
  1858.     case varDate:
  1859.       os << "varDate: " << arg.VDate;
  1860.       break;
  1861.     case varOleStr:
  1862.       os << "varOleStr: " << AnsiString(arg.VOleStr);
  1863.       break;
  1864.     case varDispatch:
  1865.       os << "varDispatch: " << static_cast<void*>(arg.VDispatch);
  1866.       break;
  1867.     case varError:
  1868.       os << "varError: " << arg.VError;
  1869.       break;
  1870.     case varBoolean:
  1871.       os << "varBoolean: " << arg.operator bool();
  1872.       break;
  1873.     case varUnknown:
  1874.       os << "varUnknown: " << static_cast<void*>(arg.VUnknown);
  1875.       break;
  1876.     case varByte:
  1877.       os << "varByte: " << arg.VByte;
  1878.       break;
  1879.     case varString:
  1880.       os << "varString: " << arg.operator AnsiString();
  1881.       break;
  1882.     case varArray:
  1883.       os << "varArray: " << static_cast<void*>(arg.VArray);
  1884.       break;
  1885.     case varSmallint | varByRef:
  1886.       os << "varSmallint | varByRef: " << arg.VPointer;
  1887.       break;
  1888.     case varInteger | varByRef:
  1889.       os << "varInteger | varByRef: " << arg.VPointer;
  1890.       break;
  1891.     case varSingle | varByRef:
  1892.       os << "varSingle | varByRef: " << arg.VPointer;
  1893.       break;
  1894.     case varDouble | varByRef:
  1895.       os << "varDouble | varByRef: " << arg.VPointer;
  1896.       break;
  1897.     case varCurrency | varByRef:
  1898.       os << "varCurrency | varByRef: " << arg.VPointer;
  1899.       break;
  1900.     case varDate | varByRef:
  1901.       os << "varDate | varByRef: " << arg.VPointer;
  1902.       break;
  1903.     case varOleStr | varByRef:
  1904.       os << "varOleStr | varByRef: " << arg.VPointer;
  1905.       break;
  1906.     case varDispatch | varByRef:
  1907.       os << "varDispatch | varByRef: " << arg.VPointer;
  1908.       break;
  1909.     case varError | varByRef:
  1910.       os << "varError | varByRef: " << arg.VPointer;
  1911.       break;
  1912.     case varBoolean | varByRef:
  1913.       os << "varBoolean | varByRef: " << arg.VPointer;
  1914.       break;
  1915.     case varUnknown | varByRef:
  1916.       os << "varUnknown | varByRef: " << arg.VPointer;
  1917.       break;
  1918.     case varByte | varByRef:
  1919.       os << "varByte | varByRef: " << arg.VPointer;
  1920.       break;
  1921.     case varString | varByRef:
  1922.       os << "varString | varByRef: " << arg.VPointer;
  1923.       break;
  1924.     case varArray | varByRef:
  1925.       os << "varArray | varByRef: " << arg.VPointer;
  1926.       break;
  1927.   }
  1928.   return os;
  1929. }
  1930.  
  1931. AutoCmd::AutoCmd(const AutoCmd& src): Name(src.Name), Parms(src.Parms),
  1932.   ParmTypes(src.ParmTypes), NamedParms(src.NamedParms),
  1933.   NamedParmTypes(src.NamedParmTypes), NamedParmNames(src.NamedParmNames)
  1934. {
  1935.   for (int i = 0; i < MaxDispArgs; i++)
  1936.   {
  1937.     StringArgs[i] = src.StringArgs[i];
  1938.     StringPtrs[i] = src.StringPtrs[i];
  1939.     NamedStringArgs[i] = NamedStringArgs[i];
  1940.     NamedStringPtrs[i] = NamedStringPtrs[i];
  1941.   }
  1942. }
  1943.  
  1944. AutoCmd& AutoCmd::SetName(const String& name)
  1945. {
  1946.   Name = name;
  1947.   return *this;
  1948. }
  1949.  
  1950. AutoCmd& AutoCmd::Clear()
  1951. {
  1952.   ClearName();
  1953.   ClearArgs();
  1954.   return *this;
  1955. }
  1956.  
  1957. AutoCmd& AutoCmd::ClearName()
  1958. {
  1959.   SetName("");
  1960.   return *this;
  1961. }
  1962.  
  1963. AutoCmd& AutoCmd::ClearArgs()
  1964. {
  1965.   Parms.Clear();
  1966.   ParmTypes.Clear();
  1967.  
  1968.   NamedParms.Clear();
  1969.   NamedParmTypes.Clear();
  1970.   NamedParmNames.Clear();
  1971.  
  1972.   return *this;
  1973. }
  1974.  
  1975. int AutoCmd::GetArgType(const Byte idx) const
  1976. {
  1977.   if (ParmTypes.IsEmpty() || ParmTypes.ArrayHighBound() < idx)
  1978.     throw new EVariantError(sAcGatRange);
  1979.   return ParmTypes.GetElement(idx);
  1980. }
  1981.  
  1982. int AutoCmd::GetNamedArgType(const Byte idx) const
  1983. {
  1984.   if (NamedParmTypes.IsEmpty() || NamedParmTypes.ArrayHighBound() < idx)
  1985.     throw new EVariantError(sAcGnatRange);
  1986.   return NamedParmTypes.GetElement(idx);
  1987. }
  1988.  
  1989. Byte AutoCmd::GetArgCount() const
  1990. {
  1991.   int count = GetNamedArgCount();
  1992.   if (!Parms.IsEmpty())
  1993.     count += Parms.ArrayHighBound() + 1;
  1994.   return (Byte) count;
  1995. }
  1996.  
  1997. Byte AutoCmd::GetNamedArgCount() const
  1998. {
  1999.   int count = 0;
  2000.   if (!NamedParms.IsEmpty())
  2001.     count += NamedParms.ArrayHighBound() + 1;
  2002.   return (Byte)count;
  2003. }
  2004.  
  2005. Variant& AutoCmd::GetParm(const Byte idx)
  2006. {
  2007.   if (Parms.IsEmpty() || Parms.ArrayHighBound() < idx)
  2008.     throw new EVariantError(sAcGpRange);
  2009.   return Parms[idx];
  2010. }
  2011.  
  2012. Variant& AutoCmd::GetNamedParm(const Byte idx)
  2013. {
  2014.   if (NamedParms.IsEmpty() || NamedParms.ArrayHighBound() < idx)
  2015.     throw new EVariantError(sAcGnpRange);
  2016.   return NamedParms[idx];
  2017. }
  2018.  
  2019. String AutoCmd::GetNamedParmName(const Byte idx) const
  2020. {
  2021.   if (NamedParms.IsEmpty() || NamedParms.ArrayHighBound() < idx)
  2022.     throw new EVariantError(sAcGnpnRange);
  2023.   return NamedParmNames.GetElement(idx);
  2024. }
  2025.  
  2026. void AutoCmd::AddElement()
  2027. {
  2028.   if (Parms.IsEmpty())
  2029.   {
  2030.     Parms = Variant(OPENARRAY(int, (0, 0)), varVariant);
  2031.     ParmTypes = Variant(OPENARRAY(int, (0, 0)), varInteger);
  2032.   }
  2033.   else
  2034.   {
  2035.     Parms.ArrayRedim(Parms.ArrayHighBound()+1);
  2036.     ParmTypes.ArrayRedim(ParmTypes.ArrayHighBound()+1);
  2037.   }
  2038. }
  2039.  
  2040. AutoCmd& AutoCmd::operator <<(const Variant& v)
  2041. {
  2042.   AddElement();
  2043.   Parms.PutElement(v, Parms.ArrayHighBound());
  2044.   ParmTypes.PutElement(varVariant, ParmTypes.ArrayHighBound());
  2045.   return *this;
  2046. }
  2047.  
  2048. AutoCmd& AutoCmd::operator <<(const short arg)
  2049. {
  2050.   AddElement();
  2051.   Parms.PutElement(arg, Parms.ArrayHighBound());
  2052.   ParmTypes.PutElement(varSmallint, ParmTypes.ArrayHighBound());
  2053.   return *this;
  2054. }
  2055.  
  2056. AutoCmd& AutoCmd::operator <<(const int arg)
  2057. {
  2058.   AddElement();
  2059.   Parms.PutElement(arg, Parms.ArrayHighBound());
  2060.   ParmTypes.PutElement(varInteger, ParmTypes.ArrayHighBound());
  2061.   return *this;
  2062. }
  2063.  
  2064. AutoCmd& AutoCmd::operator <<(const float arg)
  2065. {
  2066.   AddElement();
  2067.   Parms.PutElement(arg, Parms.ArrayHighBound());
  2068.   ParmTypes.PutElement(varSingle, ParmTypes.ArrayHighBound());
  2069.   return *this;
  2070. }
  2071.  
  2072. AutoCmd& AutoCmd::operator <<(const double arg)
  2073. {
  2074.   AddElement();
  2075.   Parms.PutElement(arg, Parms.ArrayHighBound());
  2076.   ParmTypes.PutElement(varDouble, ParmTypes.ArrayHighBound());
  2077.   return *this;
  2078. }
  2079.  
  2080. AutoCmd& AutoCmd::operator <<(const Currency arg)
  2081. {
  2082.   AddElement();
  2083.   Parms.PutElement(arg, Parms.ArrayHighBound());
  2084.   ParmTypes.PutElement(varCurrency, ParmTypes.ArrayHighBound());
  2085.   return *this;
  2086. }
  2087.  
  2088. AutoCmd& AutoCmd::operator <<(const TDateTime arg)
  2089. {
  2090.   AddElement();
  2091.   Parms.PutElement(arg, Parms.ArrayHighBound());
  2092.   ParmTypes.PutElement(varDate, ParmTypes.ArrayHighBound());
  2093.   return *this;
  2094. }
  2095.  
  2096. AutoCmd& AutoCmd::operator <<(const bool arg)
  2097. {
  2098.   AddElement();
  2099.   Parms.PutElement(arg, Parms.ArrayHighBound());
  2100.   ParmTypes.PutElement(varBoolean, ParmTypes.ArrayHighBound());
  2101.   return *this;
  2102. }
  2103.  
  2104. AutoCmd& AutoCmd::operator <<(const WordBool arg)
  2105. {
  2106.   AddElement();
  2107.   Parms.PutElement(arg, Parms.ArrayHighBound());
  2108.   ParmTypes.PutElement(varBoolean, ParmTypes.ArrayHighBound());
  2109.   return *this;
  2110. }
  2111.  
  2112. AutoCmd& AutoCmd::operator <<(const Byte arg)
  2113. {
  2114.   AddElement();
  2115.   Parms.PutElement(arg, Parms.ArrayHighBound());
  2116.   ParmTypes.PutElement(varByte, ParmTypes.ArrayHighBound());
  2117.   return *this;
  2118. }
  2119.  
  2120. AutoCmd& AutoCmd::operator <<(const AnsiString& arg)
  2121. {
  2122.   AddElement();
  2123.   int dummy = 0;
  2124.   Parms.PutElement(dummy, Parms.ArrayHighBound());
  2125.   ParmTypes.PutElement(varString, ParmTypes.ArrayHighBound());
  2126.   StringArgs[Parms.ArrayHighBound()] = arg;
  2127.   return *this;
  2128. }
  2129.  
  2130. AutoCmd& AutoCmd::operator <<(Ole2::IDispatch* const arg)
  2131. {
  2132.   AddElement();
  2133.   Parms.PutElement(arg, Parms.ArrayHighBound());
  2134.   ParmTypes.PutElement(varDispatch, ParmTypes.ArrayHighBound());
  2135.   return *this;
  2136. }
  2137.  
  2138. AutoCmd& AutoCmd::operator <<(Ole2::IUnknown* const arg)
  2139. {
  2140.   AddElement();
  2141.   Parms.PutElement(arg, Parms.ArrayHighBound());
  2142.   ParmTypes.PutElement(varUnknown, ParmTypes.ArrayHighBound());
  2143.   return *this;
  2144. }
  2145.  
  2146. AutoCmd& AutoCmd::operator <<(Variant* arg)
  2147. {
  2148.   Variant v;
  2149.   v.VType = varVariant | varByRef;
  2150.   v.VPointer = arg;
  2151.   AddElement();
  2152.   Parms.PutElement(v, Parms.ArrayHighBound());
  2153.   ParmTypes.PutElement(varVariant | varByRef, ParmTypes.ArrayHighBound());
  2154.   return *this;
  2155. }
  2156.  
  2157. AutoCmd& AutoCmd::operator <<(short* arg)
  2158. {
  2159.   AddElement();
  2160.   Parms.PutElement(arg, Parms.ArrayHighBound());
  2161.   ParmTypes.PutElement(varSmallint | varByRef, ParmTypes.ArrayHighBound());
  2162.   return *this;
  2163. }
  2164.  
  2165. AutoCmd& AutoCmd::operator <<(int* arg)
  2166. {
  2167.   AddElement();
  2168.   Parms.PutElement(arg, Parms.ArrayHighBound());
  2169.   ParmTypes.PutElement(varInteger | varByRef, ParmTypes.ArrayHighBound());
  2170.   return *this;
  2171. }
  2172.  
  2173. AutoCmd& AutoCmd::operator <<(float* arg)
  2174. {
  2175.   AddElement();
  2176.   Parms.PutElement(arg, Parms.ArrayHighBound());
  2177.   ParmTypes.PutElement(varSingle | varByRef, ParmTypes.ArrayHighBound());
  2178.   return *this;
  2179. }
  2180.  
  2181. AutoCmd& AutoCmd::operator <<(double* arg)
  2182. {
  2183.   AddElement();
  2184.   Parms.PutElement(arg, Parms.ArrayHighBound());
  2185.   ParmTypes.PutElement(varDouble | varByRef, ParmTypes.ArrayHighBound());
  2186.   return *this;
  2187. }
  2188.  
  2189. AutoCmd& AutoCmd::operator <<(Currency* arg)
  2190. {
  2191.   AddElement();
  2192.   Parms.PutElement(arg, Parms.ArrayHighBound());
  2193.   ParmTypes.PutElement(varCurrency | varByRef, ParmTypes.ArrayHighBound());
  2194.   return *this;
  2195. }
  2196.  
  2197. AutoCmd& AutoCmd::operator <<(TDateTime* arg)
  2198. {
  2199.   AddElement();
  2200.   Parms.PutElement(arg, Parms.ArrayHighBound());
  2201.   ParmTypes.PutElement(varDate | varByRef, ParmTypes.ArrayHighBound());
  2202.   return *this;
  2203. }
  2204.  
  2205. AutoCmd& AutoCmd::operator <<(WordBool* arg)
  2206. {
  2207.   AddElement();
  2208.   Parms.PutElement(arg, Parms.ArrayHighBound());
  2209.   ParmTypes.PutElement(varBoolean | varByRef, ParmTypes.ArrayHighBound());
  2210.   return *this;
  2211. }
  2212.  
  2213. AutoCmd& AutoCmd::operator <<(Byte* arg)
  2214. {
  2215.   AddElement();
  2216.   Parms.PutElement(arg, Parms.ArrayHighBound());
  2217.   ParmTypes.PutElement(varByte | varByRef, ParmTypes.ArrayHighBound());
  2218.   return *this;
  2219. }
  2220.  
  2221. AutoCmd& AutoCmd::operator <<(AnsiString* arg)
  2222. {
  2223.   AddElement();
  2224.   int dummy = 0;
  2225.   Parms.PutElement(dummy, Parms.ArrayHighBound());
  2226.   ParmTypes.PutElement(varString | varByRef, ParmTypes.ArrayHighBound());
  2227.   StringPtrs[Parms.ArrayHighBound()] = arg;
  2228.   return *this;
  2229. }
  2230.  
  2231. AutoCmd& AutoCmd::operator <<(const NamedParm& np)
  2232. {
  2233.   if (NamedParms.IsEmpty())
  2234.   {
  2235.     NamedParms     = Variant(OPENARRAY(int, (0, 0)), varVariant);
  2236.     NamedParmTypes = Variant(OPENARRAY(int, (0, 0)), varInteger);
  2237.     NamedParmNames = Variant(OPENARRAY(int, (0, 0)), varVariant);
  2238.   }
  2239.   else
  2240.   {
  2241.     NamedParms.ArrayRedim(NamedParms.ArrayHighBound()+1);
  2242.     NamedParmTypes.ArrayRedim(NamedParmTypes.ArrayHighBound()+1);
  2243.     NamedParmNames.ArrayRedim(NamedParmNames.ArrayHighBound()+1);
  2244.   }
  2245.  
  2246.   NamedParmNames[NamedParmNames.ArrayHighBound()] = np.GetParmName();
  2247.   int parmType = np.GetType();
  2248.   NamedParmTypes.PutElement(parmType, NamedParmTypes.ArrayHighBound());
  2249.   if (parmType == varString)
  2250.   {
  2251.     int dummy = 0;
  2252.     NamedParms.PutElement(dummy, NamedParms.ArrayHighBound());
  2253.     NamedStringArgs[NamedParms.ArrayHighBound()] = np.GetStringParm();
  2254.   }
  2255.   else if (parmType == (varString | varByRef))
  2256.   {
  2257.     int dummy = 0;
  2258.     NamedParms.PutElement(dummy, NamedParms.ArrayHighBound());
  2259.     NamedStringPtrs[NamedParms.ArrayHighBound()] = np.GetStringPtr();
  2260.   }
  2261.   else
  2262.     NamedParms.PutElement(np.GetParm(), NamedParms.ArrayHighBound());
  2263.  
  2264.   return *this;
  2265. }
  2266.  
  2267. NamedParm::NamedParm(const String& name, Variant* arg): Name(name),
  2268.   Type(varVariant | varByRef)
  2269. {
  2270.   Variant v;
  2271.   v.VType = varVariant | varByRef;
  2272.   v.VPointer = arg;
  2273.   Parm = v;
  2274. }
  2275.  
  2276. Byte Procedure::GetCallType() const
  2277. {
  2278.   return DISPATCH_METHOD;
  2279. }
  2280.  
  2281. Byte Function::GetCallType() const
  2282. {
  2283.   return DISPATCH_METHOD;
  2284. }
  2285.  
  2286. Byte PropertySet::GetCallType() const
  2287. {
  2288.   return DISPATCH_PROPERTYPUT;
  2289. }
  2290.  
  2291. Byte PropertyGet::GetCallType() const
  2292. {
  2293.   return DISPATCH_PROPERTYGET;
  2294. }
  2295.  
  2296. //---------------------------------------------------------------------
  2297. //!JK DateTime functions are kind of just shoved in here for now
  2298. //statics
  2299. TDateTime __fastcall TDateTime::CurrentDate()
  2300. {
  2301.   //TDateTime t = ::Date();
  2302.   //return t;
  2303. #if defined(PRONTO_NAMESPACES)
  2304.   return Sysutils::Date();
  2305. #else
  2306.   return ::Date();
  2307. #endif
  2308. }
  2309.  
  2310. TDateTime __fastcall TDateTime::CurrentTime()
  2311. {
  2312. #if defined(PRONTO_NAMESPACES)
  2313.   return Sysutils::Time();
  2314. #else
  2315.   return ::Time();
  2316. #endif
  2317. }
  2318.  
  2319. TDateTime __fastcall TDateTime::CurrentDateTime()
  2320. {
  2321. #if defined(PRONTO_NAMESPACES)
  2322.   return Sysutils::Now();
  2323. #else
  2324.   return ::Now();
  2325. #endif
  2326. }
  2327.  
  2328. TDateTime __fastcall TDateTime::FileDateToDateTime(int fileDate)
  2329. {
  2330. #if defined(PRONTO_NAMESPACES)
  2331.   return Sysutils::FileDateToDateTime(fileDate);
  2332. #else
  2333.   return ::FileDateToDateTime(fileDate);
  2334. #endif
  2335. }
  2336.  
  2337. //ctors
  2338. __fastcall TDateTime::TDateTime(const AnsiString& src, TDateTimeFlag flag)
  2339. {
  2340.   TDateTime tmp;
  2341.   if (flag == DateTime )
  2342. #if defined(PRONTO_NAMESPACES)
  2343.     tmp = Sysutils::StrToDateTime(src);
  2344. #else
  2345.     tmp = ::StrToDateTime(src);
  2346. #endif
  2347.   else if (flag == Date)
  2348. #if defined(PRONTO_NAMESPACES)
  2349.     tmp = Sysutils::StrToDate(src);
  2350. #else
  2351.     tmp = ::StrToDate(src);
  2352. #endif
  2353.   else // flag == Time
  2354. #if defined(PRONTO_NAMESPACES)
  2355.     tmp = Sysutils::StrToTime(src);
  2356. #else
  2357.     tmp = ::StrToTime(src);
  2358. #endif
  2359.   Val = tmp.Val;
  2360. }
  2361.  
  2362. __fastcall TDateTime::TDateTime(unsigned short year, unsigned short month,
  2363.                                 unsigned short day)
  2364. {
  2365. #if defined(PRONTO_NAMESPACES)
  2366.   TDateTime tmp = Sysutils::EncodeDate(year, month, day);
  2367. #else
  2368.   TDateTime tmp = ::EncodeDate(year, month, day);
  2369. #endif
  2370.   Val = tmp.Val;
  2371. }
  2372.  
  2373. __fastcall TDateTime::TDateTime(unsigned short hour, unsigned short min,
  2374.                                 unsigned short sec, unsigned short msec)
  2375. {
  2376. #if defined(PRONTO_NAMESPACES)
  2377.   TDateTime tmp = Sysutils::EncodeTime(hour, min, sec, msec);
  2378. #else
  2379.   TDateTime tmp = ::EncodeTime(hour, min, sec, msec);
  2380. #endif
  2381.   Val = tmp.Val;
  2382. }
  2383.  
  2384. //other TDateTime functions
  2385. __fastcall TDateTime::operator AnsiString() const
  2386. {
  2387.   if (Val < 1)
  2388. #if defined(PRONTO_NAMESPACES)
  2389.     return Sysutils::TimeToStr(*this);
  2390. #else
  2391.     return ::TimeToStr(*this);
  2392. #endif
  2393.   else if ((Val - int(Val)))
  2394. #if defined(PRONTO_NAMESPACES)
  2395.     return Sysutils::DateTimeToStr(*this);
  2396.   return Sysutils::DateToStr(*this);
  2397. #else
  2398.     return ::DateTimeToStr(*this);
  2399.   return ::DateToStr(*this);
  2400. #endif
  2401.  
  2402. }
  2403.  
  2404. AnsiString __fastcall TDateTime::FormatString(const AnsiString& format)
  2405. {
  2406. #if defined(PRONTO_NAMESPACES)
  2407.   return Sysutils::FormatDateTime(format, *this);
  2408. #else
  2409.   return ::FormatDateTime(format, *this);
  2410. #endif
  2411. }
  2412.  
  2413. AnsiString __fastcall TDateTime::DateString() const
  2414. {
  2415. #if defined(PRONTO_NAMESPACES)
  2416.   return Sysutils::DateToStr(*this);
  2417. #else
  2418.   return ::DateToStr(*this);
  2419. #endif
  2420. }
  2421.  
  2422. AnsiString __fastcall TDateTime::TimeString() const
  2423. {
  2424. #if defined(PRONTO_NAMESPACES)
  2425.   return Sysutils::TimeToStr(*this);
  2426. #else
  2427.   return ::TimeToStr(*this);
  2428. #endif
  2429. }
  2430.  
  2431. AnsiString __fastcall TDateTime::DateTimeString() const
  2432. {
  2433. #if defined(PRONTO_NAMESPACES)
  2434.   return Sysutils::DateTimeToStr(*this);
  2435. #else
  2436.   return ::DateTimeToStr(*this);
  2437. #endif
  2438. }
  2439.  
  2440. int __fastcall TDateTime::DayOfWeek() const
  2441. {
  2442. #if defined(PRONTO_NAMESPACES)
  2443.   return Sysutils::DayOfWeek(*this);
  2444. #else
  2445.   return ::DayOfWeek(*this);
  2446. #endif
  2447. }
  2448.  
  2449. int __fastcall TDateTime::FileDate() const
  2450. {
  2451. #if defined(PRONTO_NAMESPACES)
  2452.   return Sysutils::DateTimeToFileDate(*this);
  2453. #else
  2454.   return ::DateTimeToFileDate(*this);
  2455. #endif
  2456. }
  2457. void __fastcall TDateTime::DecodeDate(unsigned short* year,
  2458.   unsigned short* month, unsigned short* day) const
  2459. {
  2460. #if defined(PRONTO_NAMESPACES)
  2461.   Sysutils::DecodeDate(*this, *year, *month, *day);
  2462. #else
  2463.   ::DecodeDate(*this, *year, *month, *day);
  2464. #endif
  2465. }
  2466. void __fastcall TDateTime::DecodeTime(unsigned short* hour,
  2467.   unsigned short* min, unsigned short* sec, unsigned short* msec) const
  2468. {
  2469. #if defined(PRONTO_NAMESPACES)
  2470.   Sysutils::DecodeTime(*this, *hour, *min, *sec, *msec);
  2471. #else
  2472.   ::DecodeTime(*this, *hour, *min, *sec, *msec);
  2473. #endif
  2474. }
  2475. //-----------------------------------------------------------------------
  2476. //!JK These Currency functions are kind of just shoved in here
  2477. __fastcall Currency::Currency(const AnsiString& src)
  2478. {
  2479. #if defined(PRONTO_NAMESPACES)
  2480.   *this = Sysutils::StrToCurr(src);
  2481. #else
  2482.   *this = ::StrToCurr(src);
  2483. #endif
  2484. }
  2485. //-----------------------------------------------------------------------
  2486. __fastcall Currency::operator AnsiString() const
  2487. {
  2488.   return CurrToStr(*this);
  2489. }
  2490.  
  2491. #if defined(PRONTO_NAMESPACES)
  2492. }
  2493. #endif
  2494.  
  2495.