home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / vgserv45.zip / BASE / HPTWGS2 / include / fcwexp.h < prev    next >
C/C++ Source or Header  |  2001-03-21  |  33KB  |  1,287 lines
  1. /*****************************************************************************/
  2. /*                                                                           */
  3. /*                           OCO SOURCE MATERIALS                            */
  4. /*                             IBM CONFIDENTIAL                              */
  5. /*                                    OR                                     */
  6. /*                        IBM CONFIDENTIAL RESTRICTED                        */
  7. /*            WHEN COMBINED WITH THE AGGREGATED OCO SOURCE MODULES           */
  8. /*                           FOR THIS PROGRAM PRODUCT                        */
  9. /*                                                                           */
  10. /*   VisualAge Generator Server for OS/2, AIX, HP-UX, SUN, Windows NT, and   */
  11. /*                      SCO OpenServer  -  Version 4.1                       */
  12. /*                    (C) COPYRIGHT IBM CORP. 1994, 2000                     */
  13. /*                                                                           */
  14. /*****************************************************************************/
  15. #ifndef FCWEXP_H
  16. #define FCWEXP_H
  17.  
  18. #include <stdlib.h>
  19. #include <stdio.h>
  20. #include <string.h>
  21. #include <stddef.h>
  22. #include <math.h>
  23. #include <memory.h>
  24. #include <iostream.h>
  25. #include <iomanip.h>
  26. #include <ctype.h>
  27.  
  28. #if defined FCW_NT || defined FCW_OS2
  29. #elif defined FCW_HP || defined FCW_SUN || defined FCW_SCO
  30. #include <wchar.h>
  31. #else
  32. #include <wcstr.h>
  33. #endif
  34.  
  35. enum Level { Leaf, Group, Single};
  36.  
  37.  
  38. /* **********************************************************************/
  39. /* Declare forward references                                           */
  40. /* **********************************************************************/
  41. class Item;
  42. class Parent;
  43. class RPCParm;
  44. class quadnum;
  45. class TraceFile;
  46. class CHA;
  47.  
  48. /* **********************************************************************/
  49. /* Declare global functions                                             */
  50. /* **********************************************************************/
  51. void UserOverflow();
  52. void MaxOverflow();
  53.  
  54. /* **********************************************************************/
  55. /* Object for literal (CHA, MIX, DBCS) parameter on CALL statement      */
  56. /* **********************************************************************/
  57. class LitParm : public Parameter
  58. {
  59.   public:
  60.    LitParm( char* p );
  61.    LitParm( long  p );
  62.    virtual ~LitParm();
  63.    virtual ItemType  itemType()        const;
  64.  
  65.    long ParmSize();
  66.    char* ParmData();
  67.  
  68.                                        /* For RPC                          */
  69.    int& fNumberOfRPCEntries();
  70.    LIST(RPCParm*)& RPCList();
  71.    void SetupRpc();
  72.  
  73.   private:
  74.    LIST(RPCParm*) LRPCParm;                            /* List of RPC Parms*/
  75.    int            numberOfRPCEntries;
  76.    FCWString      s;
  77.    long           binlit;
  78.    ItemType       type;
  79.    void*          pData;
  80. };
  81.  
  82.  
  83. /* **********************************************************************/
  84. /* Item                                                                 */
  85. /* **********************************************************************/
  86.  
  87. class Item : public Parameter
  88. {
  89.   public:
  90.  
  91.     char*             Data(int i=1) const;              /* Empty Array item*/
  92.     int               Length()      const;
  93.     int               Byte()        const;
  94.     Bool              IsLeaf()      const;
  95.     virtual int       Occurs()      const;
  96.     void              SetOccurs(int);
  97.     int               Offset()      const;
  98.     ItemType          Type()        const;
  99.     virtual ItemType  itemType()    const;
  100.     Bool              TypeIsPack()  const;
  101.     Bool              TypeIsSQL()   const;
  102.     Bool              TypeIsDBCS()  const;
  103.     Bool              TypeIsUnicode()  const;                        /*12123*/
  104.     int               Scale()       const;
  105.     int               Precision()   const;     /* ODBC                     */
  106.     void              ConvertData( char, FILE* );
  107.  
  108.     virtual void      SetEmpty() const { };
  109.     virtual void      SetNull() const { };
  110.     virtual void      SetClear() { };
  111.     virtual Bool      IsNull() const ; /* ODBC                             */
  112.     virtual FCWString StringForm();
  113.     virtual int       LengthWOTBlanks();
  114.     int&              fNumberOfRPCEntries();
  115.     LIST(RPCParm*)&   RPCList();
  116.     void              SetupRpc();
  117.     int               GetOccurOffset() const ;
  118.     Parent&           parent() const;
  119.     Item operator [] (int) const;
  120.  
  121.     virtual           ~Item();
  122.  
  123.   protected:
  124.  
  125.     Item(Parent&, Level, int, int, int, int);
  126.     Item(const Item&, int);
  127.  
  128.     void              SetByte(int);
  129.  
  130.     long              ParmSize();      /* Level 77 item only               */
  131.     char*             ParmData();
  132.  
  133.     void              SetType(ItemType);
  134.     void              SetScale(int);
  135.     void              SetPrecision( int );                       // ODBC
  136.  
  137.   private:
  138.     int            numberOfRPCEntries;
  139.     LIST(RPCParm*) LRPCParm;                           /* List of RPC Parms*/
  140.     Parent&        iparent;
  141.     char *         parm;
  142.     Level          level;
  143.     int            offset;
  144.     int            length;
  145.     int            occurs;
  146.     int            occurs_offset;
  147.     ItemType       type;
  148.     int            scale;
  149.     int            precision;          /* ODBC                             */
  150.     int            byte;
  151.     void*          pData;
  152. };
  153.  
  154.  
  155. /* **********************************************************************/
  156. /* ChaItem :  for CHA, DBCS, HEX, and MIX                               */
  157. /* **********************************************************************/
  158.  
  159. class ChaItem : public Item
  160. {
  161.   protected:
  162.     ChaItem(Parent&, Level, int, int, int, int);
  163.     ChaItem(const ChaItem&, int);
  164.     virtual ~ChaItem();
  165.  
  166.   public:
  167.     operator FCWString() const;
  168.     virtual int LengthWOTBlanks();
  169.  
  170.   private:
  171.     void*    pData;
  172. };
  173.  
  174. int  operator == ( const char *c1, const ChaItem& c2 );
  175. int  operator <  ( const char *c1, const ChaItem& c2 );
  176. int  operator >  ( const char *c1, const ChaItem& c2 );
  177.  
  178. inline
  179. int  operator != ( const char *c1, const ChaItem& c2 )
  180. {
  181.    return (!( c1 == c2 ));
  182. }
  183.  
  184. inline
  185. int  operator <= ( const char *c1, const ChaItem& c2 )
  186. {
  187.    return (!( c1 > c2 ));
  188. }
  189.  
  190. inline
  191. int  operator >= ( const char *c1, const ChaItem& c2 )
  192. {
  193.    return (!( c1 < c2 ));
  194. }
  195.  
  196.  
  197. /* **********************************************************************/
  198. /* NumItem                                                              */
  199. /* **********************************************************************/
  200.  
  201. class NumItem : public Item
  202. {
  203.   public:
  204.     virtual int       Decimals() const;
  205.     int               longValue() const;
  206.     virtual           operator quadnum () const = 0;
  207.     virtual void      operator = (const quadnum&) =0;
  208.     virtual FCWString StringForm();
  209.  
  210.   protected:
  211.  
  212.     NumItem(Parent&, Level, int, int, int, int, int);
  213.     NumItem(const NumItem&, int);
  214.     virtual ~NumItem();
  215.  
  216.   private:
  217.  
  218.     int      decimals;
  219.     void*    pData;
  220. };
  221.  
  222. int     operator == ( const NumItem& n, const quadnum& q );
  223. int     operator <  ( const NumItem& n, const quadnum& q );
  224. int     operator >  ( const NumItem& n, const quadnum& q );
  225.  
  226. inline
  227. int     operator != (const NumItem& n, const quadnum& q)
  228. {
  229.    return (!( n == q ));
  230. }
  231.  
  232. inline
  233. int     operator >= (const NumItem& n, const quadnum& q)
  234. {
  235.    return (!( n < q ));
  236. }
  237.  
  238. inline
  239. int     operator <= (const NumItem& n, const quadnum& q)
  240. {
  241.    return (!( n > q ));
  242. }
  243.  
  244. int     operator == ( const NumItem& n, const NumItem& q );
  245. int     operator <  ( const NumItem& n, const NumItem& q );
  246. int     operator >  ( const NumItem& n, const NumItem& q );
  247.  
  248. inline
  249. int     operator != (const NumItem& n, const NumItem& q)
  250. {
  251.    return (!( n == q ));
  252. }
  253.  
  254. inline
  255. int     operator >= (const NumItem& n, const NumItem& q)
  256. {
  257.    return (!( n < q ));
  258. }
  259.  
  260. inline
  261. int     operator <= (const NumItem& n, const NumItem& q)
  262. {
  263.    return (!( n > q ));
  264. }
  265.  
  266. inline
  267. int     operator == ( const quadnum& n, const NumItem& q )
  268. {
  269.    return ( q == n );
  270. }
  271.  
  272. inline
  273. int     operator <  ( const quadnum& n, const NumItem& q )
  274. {
  275.    return ( q > n );
  276. }
  277.  
  278. inline
  279. int     operator >  ( const quadnum& n, const NumItem& q )
  280. {
  281.    return ( q < n );
  282. }
  283.  
  284. inline
  285. int     operator != (const quadnum& n, const NumItem& q)
  286. {
  287.    return ( q != n );
  288. }
  289.  
  290. inline
  291. int     operator >= (const quadnum& n, const NumItem& q)
  292. {
  293.    return ( q <= n );
  294. }
  295.  
  296. inline
  297. int     operator <= (const quadnum& n, const NumItem& q)
  298. {
  299.    return ( q >= n );
  300. }
  301.  
  302. /* *************************************************************************/
  303. /* BIN2                                                                    */
  304. /* *************************************************************************/
  305.  
  306. class BIN2 : public NumItem
  307. {
  308.   public:
  309.  
  310.     BIN2 (Parent&, Level, int, int, int, int, int=0);
  311.     BIN2 (int, int, int);
  312.     BIN2 (const BIN2&, int);
  313.     BIN2 (const BIN2&, quadnum );
  314.     virtual ~BIN2();
  315.  
  316.     void SetEmpty () const;
  317.  
  318.     virtual operator quadnum () const;
  319.     BIN2 operator [] (quadnum) const;
  320.  
  321.     quadnum operator - () const;
  322.     quadnum operator + () const;
  323.  
  324.     void operator = (const BIN2&);
  325.     virtual void operator = (const quadnum& v);
  326.     void operator <<= (const quadnum& v);      /* arith round operator     */
  327.  
  328.     int Contains( const quadnum& v,  int=1 );
  329.     int Contains( const quadnum& v,  NumItem& itm );
  330.  
  331.   private:
  332.     void*    pData;
  333. };
  334.  
  335.  
  336. /* *************************************************************************/
  337. /* BIN4                                                                    */
  338. /* *************************************************************************/
  339.  
  340. class BIN4 : public NumItem
  341. {
  342.   public:
  343.  
  344.     BIN4 (Parent&, Level, int, int, int, int, int=0);
  345.     BIN4 (int, int, int);
  346.     BIN4 (const BIN4&, int);
  347.     BIN4 (const BIN4&, quadnum);
  348.     virtual ~BIN4();
  349.  
  350.     void SetEmpty () const ;
  351.  
  352.     virtual operator quadnum () const;
  353.     BIN4 operator [] (quadnum) const;
  354.  
  355.     quadnum operator - () const;
  356.     quadnum operator + () const;
  357.  
  358.     void operator = (const BIN4&);
  359.     virtual void operator = (const quadnum& v);
  360.     void operator <<= (const quadnum& v);      /* arith round operator     */
  361.  
  362.     int Contains( const quadnum& v,  int=1 );
  363.     int Contains( const quadnum& v,  NumItem& itm );
  364.  
  365.   private:
  366.     void*    pData;
  367. };
  368.  
  369. /* *************************************************************************/
  370. /* BIN8                                                                    */
  371. /* *************************************************************************/
  372.  
  373. class BIN8 : public NumItem
  374. {
  375.   public:
  376.  
  377.     BIN8 (Parent&, Level, int, int, int, int, int=0);
  378.     BIN8 (int, int, int);
  379.     BIN8 (const BIN8&, int);
  380.     BIN8 (const BIN8&, quadnum);
  381.     virtual ~BIN8();
  382.  
  383.     void SetEmpty () const;
  384.  
  385.     virtual operator quadnum () const;
  386.     BIN8 operator [] (quadnum) const;
  387.  
  388.     quadnum operator - () const;
  389.     quadnum operator + () const;
  390.  
  391.     void operator = (const BIN8&);
  392.     virtual void operator = (const quadnum& v);
  393.     void operator <<= (const quadnum& v);
  394.  
  395.     int Contains( const quadnum& v,  int=1 );
  396.     int Contains( const quadnum& v,  NumItem& itm );
  397.  
  398.   private:
  399.     void*    pData;
  400. };
  401.  
  402. /* *************************************************************************/
  403. /* NUM                                                                     */
  404. /* *************************************************************************/
  405.  
  406. class NUM : public NumItem
  407. {
  408.   public:
  409.  
  410.     NUM (Parent&, Level, int, int, int, int, int=0);
  411.     NUM (int, int, int);
  412.     NUM (const NUM&, int);
  413.     NUM (const NUM&, quadnum);
  414.     virtual ~NUM();
  415.  
  416.     void SetEmpty () const;
  417.  
  418.     virtual operator quadnum () const;
  419.     NUM operator [] (quadnum) const;
  420.  
  421.     quadnum operator - () const;
  422.     quadnum operator + () const;
  423.  
  424.     void operator = (const NUM&);
  425.     virtual void operator = (const quadnum& v);
  426.     void operator <<= (const quadnum& v);
  427.  
  428.     int Contains( const quadnum& v,  int=1 );
  429.     int Contains( const quadnum& v,  NumItem& itm );
  430.     int Contains( const CHA& v,      int=1 );
  431.     int Contains( const CHA& v,      NumItem& itm );
  432.  
  433.                                        /* Interactions with CHA class      */
  434.     friend class CHA;
  435.     void operator = (const CHA& v);
  436.     int operator == (const CHA& v) const;
  437.     int operator != (const CHA& v) const;
  438.     int operator >  (const CHA& v) const;
  439.     int operator <  (const CHA& v) const;
  440.     int operator >= (const CHA& v) const;
  441.     int operator <= (const CHA& v) const;
  442.  
  443.   private:
  444.     void*    pData;
  445. };
  446.  
  447. inline
  448. int NUM :: operator != (const CHA& v) const
  449. {
  450.    return (!( *this == v ));
  451. }
  452.  
  453. inline
  454. int NUM :: operator <= (const CHA& v) const
  455. {
  456.    return (!( *this > v ));
  457. }
  458.  
  459. inline
  460. int NUM :: operator >= (const CHA& v) const
  461. {
  462.    return (!( *this < v ));
  463. }
  464.  
  465.  
  466. /* *************************************************************************/
  467. /* NUMC                                                                    */
  468. /* *************************************************************************/
  469.  
  470. class NUMC : public NumItem
  471. {
  472.   public:
  473.  
  474.     NUMC (Parent&, Level, int, int, int, int, int=0);
  475.     NUMC (int, int, int);
  476.     NUMC (const NUMC&, int);
  477.     NUMC (const NUMC&, quadnum);
  478.     virtual ~NUMC();
  479.  
  480.     void SetEmpty () const;
  481.  
  482.     virtual operator quadnum () const;
  483.     NUMC operator [] (quadnum) const;
  484.  
  485.     quadnum operator - () const;
  486.     quadnum operator + () const;
  487.  
  488.     void operator = (const NUMC&);
  489.     virtual void operator = (const quadnum& v);
  490.     void operator <<= (const quadnum& v);
  491.  
  492.     int Contains( const quadnum& v,  int=1 );
  493.     int Contains( const quadnum& v,  NumItem& itm );
  494.  
  495.   private:
  496.     void*    pData;
  497. };
  498.  
  499. /* *************************************************************************/
  500. /* PACK                                                                    */
  501. /* *************************************************************************/
  502.  
  503. class PACK : public NumItem
  504. {
  505.   public:
  506.  
  507.     PACK (Parent&, Level, int, int, int, int, int=0);
  508.     PACK (int, int, int);
  509.     PACK (const PACK&, int);
  510.     PACK (const PACK&, quadnum);
  511.     virtual ~PACK();
  512.  
  513.     void SetEmpty () const;
  514.  
  515.     virtual operator quadnum () const;
  516.     PACK operator [] (quadnum) const;
  517.  
  518.     quadnum operator - () const;
  519.     quadnum operator + () const;
  520.  
  521.     void operator = (const PACK&);
  522.     virtual void operator = (const quadnum& v);
  523.     void operator <<= (const quadnum& v);
  524.  
  525.     int Contains( const quadnum& v,  int=1 );
  526.     int Contains( const quadnum& v,  NumItem& itm );
  527.  
  528.   private:
  529.  
  530.     int      bytes;
  531.     void*    pData;
  532. };
  533.  
  534. /* *************************************************************************/
  535. /* PACF                                                                    */
  536. /* *************************************************************************/
  537.  
  538. class PACF : public NumItem
  539. {
  540.   public:
  541.  
  542.     PACF (Parent&, Level, int, int, int, int, int=0);
  543.     PACF (int, int, int);
  544.     PACF (const PACF&, int);
  545.     PACF (const PACF&, quadnum);
  546.     virtual ~PACF();
  547.  
  548.     void SetEmpty () const;
  549.  
  550.     virtual operator quadnum () const;
  551.     PACF operator [] (quadnum) const;
  552.  
  553.     quadnum operator - () const;
  554.     quadnum operator + () const;
  555.  
  556.     void operator = (const PACF&);
  557.     virtual void operator = (const quadnum& v);
  558.     void operator <<= (const quadnum& v);
  559.  
  560.     int Contains( const quadnum& v,  int=1 );
  561.     int Contains( const quadnum& v,  NumItem& itm );
  562.  
  563.   private:
  564.  
  565.     int      bytes;
  566.     void*    pData;
  567. };
  568.  
  569. /* *************************************************************************/
  570. /* HEX                                                                     */
  571. /* *************************************************************************/
  572.  
  573. class HEX : public ChaItem
  574. {
  575.   public:
  576.  
  577.     HEX (Parent&, Level, int, int, int, int);
  578.     HEX (int, int);
  579.     HEX (const HEX&, int);
  580.     HEX (const HEX&, quadnum);
  581.     virtual ~HEX();
  582.  
  583.     HEX operator [] (quadnum) const;
  584.  
  585.     void SetEmpty () const;
  586.  
  587.                                      /* Interactions with other HEX objects*/
  588.     void operator =  (const HEX& v);
  589.     int  operator == (const HEX& v) const;
  590.     int  operator != (const HEX& v) const;
  591.     int  operator >  (const HEX& v) const;
  592.     int  operator <  (const HEX& v) const;
  593.     int  operator >= (const HEX& v) const;
  594.     int  operator <= (const HEX& v) const;
  595.  
  596.                                        /* Interactions with CHA objects    */
  597.     friend class CHA;
  598.     void operator =  (const CHA& v);
  599.     int  operator == (const CHA& v) const;
  600.     int  operator != (const CHA& v) const;
  601.     int  operator >  (const CHA& v) const;
  602.     int  operator <  (const CHA& v) const;
  603.     int  operator >= (const CHA& v) const;
  604.     int  operator <= (const CHA& v) const;
  605.  
  606.                                     /* Interactions with character literals*/
  607.     void operator =  (const char *v);
  608.     int  operator == (const char *v) const;
  609.     int  operator != (const char *v) const;
  610.     int  operator >  (const char *v) const;
  611.     int  operator <  (const char *v) const;
  612.     int  operator >= (const char *v) const;
  613.     int  operator <= (const char *v) const;
  614.  
  615.     int Contains( const FCWString v, const quadnum i );
  616.  
  617.   private:
  618.     void*    pData;
  619. };
  620.  
  621. inline
  622. int EXPORT HEX :: operator != (const HEX& v) const
  623. {
  624.    return (!( *this == v ));
  625. }
  626.  
  627. inline
  628. int EXPORT HEX :: operator <= (const HEX& v) const
  629. {
  630.    return (!( *this > v ));
  631. }
  632.  
  633. inline
  634. int EXPORT HEX :: operator >= (const HEX& v) const
  635. {
  636.    return (!( *this < v ));
  637. }
  638.  
  639. inline
  640. int HEX :: operator != (const char* v) const
  641. {
  642.    return (!( *this == v ));
  643. }
  644.  
  645. inline
  646. int HEX :: operator <= (const char* v) const
  647. {
  648.    return (!( *this > v ));
  649. }
  650.  
  651. inline
  652. int HEX :: operator >= (const char* v) const
  653. {
  654.    return (!( *this < v ));
  655. }
  656.  
  657. inline
  658. int operator == ( const char* v, const HEX& h )
  659. {
  660.     return ( h == v );
  661. }
  662.  
  663. inline
  664. int operator != ( const char* v, const HEX& h )
  665. {
  666.     return ( h != v );
  667. }
  668.  
  669. inline
  670. int operator >  ( const char* v, const HEX& h )
  671. {
  672.     return ( h <  v );
  673. }
  674.  
  675. inline
  676. int operator <  ( const char* v, const HEX& h )
  677. {
  678.     return ( h >  v );
  679. }
  680.  
  681. inline
  682. int operator >= ( const char* v, const HEX& h )
  683. {
  684.     return ( h <= v );
  685. }
  686.  
  687. inline
  688. int operator <= ( const char* v, const HEX& h )
  689. {
  690.     return ( h >= v );
  691. }
  692.  
  693. /* *************************************************************************/
  694. /* CHA                                                                     */
  695. /* *************************************************************************/
  696.  
  697. class CHA : public ChaItem
  698. {
  699.   public:
  700.  
  701.     CHA (Parent&, Level, int, int, int, int);
  702.     CHA (int, int);
  703.     CHA (const CHA&, int);
  704.     CHA (const CHA&, quadnum);
  705.     virtual ~CHA();
  706.  
  707.     CHA operator [] (quadnum) const;
  708.     CHA operator [] (int) const;
  709.  
  710.     void SetEmpty () const;
  711.     Bool IsNumeric () const;
  712.     Bool IsBlank();
  713.  
  714.     void operator = (const CHA& v);
  715.     int operator == (const CHA& v) const;
  716.     int operator != (const CHA& v) const;
  717.     int operator >  (const CHA& v) const;
  718.     int operator <  (const CHA& v) const;
  719.     int operator >= (const CHA& v) const;
  720.     int operator <= (const CHA& v) const;
  721.  
  722.     friend class HEX;
  723.     void operator = (const HEX& v);
  724.     int operator == (const HEX& v) const;
  725.     int operator != (const HEX& v) const;
  726.     int operator >  (const HEX& v) const;
  727.     int operator <  (const HEX& v) const;
  728.     int operator >= (const HEX& v) const;
  729.     int operator <= (const HEX& v) const;
  730.  
  731.     friend class MIX;
  732.     void operator = (const MIX& v);
  733.     int operator == (const MIX& v) const;
  734.     int operator != (const MIX& v) const;
  735.     int operator >  (const MIX& v) const;
  736.     int operator <  (const MIX& v) const;
  737.     int operator >= (const MIX& v) const;
  738.     int operator <= (const MIX& v) const;
  739.  
  740.     friend class NUM;
  741.     void operator = (const NUM& v);
  742.     int operator == (const NUM& v) const;
  743.     int operator != (const NUM& v) const;
  744.     int operator >  (const NUM& v) const;
  745.     int operator <  (const NUM& v) const;
  746.     int operator >= (const NUM& v) const;
  747.     int operator <= (const NUM& v) const;
  748.  
  749.     void operator = (const char *v);
  750.     int operator == (const char *v) const;
  751.     int operator != (const char *v) const;
  752.     int operator >  (const char *v) const;
  753.     int operator <  (const char *v) const;
  754.     int operator >= (const char *v) const;
  755.     int operator <= (const char *v) const;
  756.  
  757.     void operator =  (const int v );
  758.     int  operator == (const int v ) const;
  759.     int  operator != (const int v ) const;
  760.     int  operator >  (const int v ) const;
  761.     int  operator <  (const int v ) const;
  762.     int  operator >= (const int v ) const;
  763.     int  operator <= (const int v ) const;
  764.  
  765.     void operator =  (const quadnum& v );
  766.     int  operator == (const quadnum& v ) const;
  767.     int  operator != (const quadnum& v ) const;
  768.     int  operator >  (const quadnum& v ) const;
  769.     int  operator <  (const quadnum& v ) const;
  770.     int  operator >= (const quadnum& v ) const;
  771.     int  operator <= (const quadnum& v ) const;
  772.  
  773.     void operator = (const FCWString& v );
  774.  
  775.     int Contains( const FCWString v, const quadnum i );
  776.     int Contains( const NUM&      v, const quadnum i );
  777.     int Contains( const CHA&      v, const quadnum i );
  778.  
  779.   private:
  780.     Bool IsValidNumeric () const;
  781.     void*    pData;
  782. };
  783.  
  784. inline
  785. int CHA :: operator != (const CHA& v) const
  786. {
  787.    return (!( *this == v ));
  788. }
  789.  
  790. inline
  791. int CHA :: operator <= (const CHA& v) const
  792. {
  793.    return (!( *this > v ));
  794. }
  795.  
  796. inline
  797. int CHA :: operator >= (const CHA& v) const
  798. {
  799.    return (!( *this < v ));
  800. }
  801.  
  802. inline
  803. int HEX :: operator == (const CHA& v) const
  804. {
  805.    return ( *this == FCWString(v) );
  806. }
  807.  
  808. inline
  809. int HEX :: operator != (const CHA& v) const
  810. {
  811.    return ( *this != FCWString(v) );
  812. }
  813.  
  814. inline
  815. int HEX :: operator < (const CHA& v) const
  816. {
  817.    return ( *this < FCWString(v) );
  818. }
  819.  
  820. inline
  821. int HEX :: operator > (const CHA& v) const
  822. {
  823.    return ( *this > FCWString(v) );
  824. }
  825.  
  826. inline
  827. int HEX :: operator <= (const CHA& v) const
  828. {
  829.    return ( *this <= FCWString(v) );
  830. }
  831.  
  832. inline
  833. int HEX :: operator >= (const CHA& v) const
  834. {
  835.    return ( *this >= FCWString(v) );
  836. }
  837.  
  838. inline
  839. int CHA :: operator == (const HEX& v) const
  840. {
  841.   return ( v == *this );
  842. }
  843.  
  844. inline
  845. int CHA :: operator != (const HEX& v) const
  846. {
  847.   return ( v != *this );
  848. }
  849.  
  850. inline
  851. int CHA :: operator < (const HEX& v) const
  852. {
  853.   return ( v > *this );
  854. }
  855.  
  856. inline
  857. int CHA :: operator > (const HEX& v) const
  858. {
  859.   return ( v < *this );
  860. }
  861.  
  862. inline
  863. int CHA :: operator <= (const HEX& v) const
  864. {
  865.   return ( v >= *this );
  866. }
  867.  
  868. inline
  869. int CHA :: operator >= (const HEX& v) const
  870. {
  871.   return ( v <= *this );
  872. }
  873.  
  874. inline
  875. int CHA :: operator != (const MIX& v) const
  876. {
  877.    return (!( *this == v ));
  878. }
  879.  
  880. inline
  881. int CHA :: operator <= (const MIX& v) const
  882. {
  883.    return (!( *this > v ));
  884. }
  885.  
  886. inline
  887. int CHA :: operator >= (const MIX& v) const
  888. {
  889.    return (!( *this < v ));
  890. }
  891.  
  892. inline
  893. int CHA :: operator == (const NUM& v) const
  894. {
  895.    return ( v == *this );
  896. }
  897.  
  898. inline
  899. int CHA :: operator != (const NUM& v) const
  900. {
  901.    return ( v != *this );
  902. }
  903.  
  904. inline
  905. int CHA :: operator < (const NUM& v)  const
  906. {
  907.    return ( v > *this );
  908. }
  909.  
  910. inline
  911. int CHA :: operator > (const NUM& v)  const
  912. {
  913.    return ( v < *this );
  914. }
  915.  
  916. inline
  917. int CHA :: operator <= (const NUM& v) const
  918. {
  919.    return ( v >= *this );
  920. }
  921.  
  922. inline
  923. int CHA :: operator >= (const NUM& v) const
  924. {
  925.    return ( v <= *this );
  926. }
  927.  
  928. inline
  929. int CHA :: operator != (const char *v) const
  930. {
  931.    return (!( *this == v ));
  932. }
  933.  
  934. inline
  935. int CHA :: operator <= (const char *v) const
  936. {
  937.    return (!( *this > v ));
  938. }
  939.  
  940. inline
  941. int CHA :: operator >= (const char *v) const
  942. {
  943.    return (!( *this < v ));
  944. }
  945.  
  946. inline
  947. int  CHA :: operator != (const int v ) const
  948. {
  949.    return (!( *this == v ));
  950. }
  951.  
  952. inline
  953. int  CHA :: operator >= (const int v ) const
  954. {
  955.    return (!( *this < v ));
  956. }
  957.  
  958. inline
  959. int  CHA :: operator <= (const int v ) const
  960. {
  961.    return (!( *this > v ));
  962. }
  963.  
  964. inline
  965. int CHA :: operator != (const quadnum& v) const
  966. {
  967.    return (!( *this == v ));
  968. }
  969.  
  970. inline
  971. int CHA :: operator >= (const quadnum& v) const
  972. {
  973.    return (!( *this < v ));
  974. }
  975.  
  976. inline
  977. int CHA :: operator <= (const quadnum& v) const
  978. {
  979.    return (!( *this > v ));
  980. }
  981.  
  982. inline
  983. int operator == ( const quadnum& q, const CHA& c )
  984. {
  985.     return ( c == q );
  986. }
  987.  
  988. inline
  989. int operator != ( const quadnum& q, const CHA& c )
  990. {
  991.     return ( c != q );
  992. }
  993.  
  994. inline
  995. int operator >  ( const quadnum& q, const CHA& c )
  996. {
  997.     return ( c <  q );
  998. }
  999.  
  1000. inline
  1001. int operator <  ( const quadnum& q, const CHA& c )
  1002. {
  1003.     return ( c >  q );
  1004. }
  1005.  
  1006. inline
  1007. int operator >= ( const quadnum& q, const CHA& c )
  1008. {
  1009.     return ( c <= q );
  1010. }
  1011.  
  1012. inline
  1013. int operator <= ( const quadnum& q, const CHA& c )
  1014. {
  1015.     return ( c >= q );
  1016. }
  1017.  
  1018. inline
  1019. int operator == ( const char* q, const CHA& c )
  1020. {
  1021.     return ( c == q );
  1022. }
  1023.  
  1024. inline
  1025. int operator != ( const char* q, const CHA& c )
  1026. {
  1027.     return ( c != q );
  1028. }
  1029.  
  1030. inline
  1031. int operator >  ( const char* q, const CHA& c )
  1032. {
  1033.     return ( c <  q );
  1034. }
  1035.  
  1036. inline
  1037. int operator <  ( const char* q, const CHA& c )
  1038. {
  1039.     return ( c >  q );
  1040. }
  1041.  
  1042. inline
  1043. int operator >= ( const char* q, const CHA& c )
  1044. {
  1045.     return ( c <= q );
  1046. }
  1047.  
  1048. inline
  1049. int operator <= ( const char* q, const CHA& c )
  1050. {
  1051.     return ( c >= q );
  1052. }
  1053.  
  1054. /* **********************************************************************/
  1055. /* DBCS                                                                 */
  1056. /* **********************************************************************/
  1057.  
  1058. class DBCS : public ChaItem
  1059. {
  1060.   public:
  1061.  
  1062.     DBCS (Parent&, Level, int, int, int, int);
  1063.     DBCS (int, int);
  1064.     DBCS (const DBCS&, int);
  1065.     DBCS (const DBCS&, quadnum);
  1066.     virtual ~DBCS();
  1067.  
  1068.     DBCS operator [] (quadnum) const;
  1069.  
  1070.     void SetEmpty () const;
  1071.     Bool IsBlank();
  1072.     virtual FCWString StringForm();
  1073.  
  1074.                                     /* Interactions with other DBCS objects*/
  1075.     void operator =  (const DBCS& v);
  1076.     int  operator == (const DBCS& v) const;
  1077.     int  operator != (const DBCS& v) const;
  1078.     int  operator >  (const DBCS& v) const;
  1079.     int  operator <  (const DBCS& v) const;
  1080.     int  operator >= (const DBCS& v) const;
  1081.     int  operator <= (const DBCS& v) const;
  1082.  
  1083.                                     /* Interactions with character literals*/
  1084.     void operator =  (const char *v);
  1085.     int  operator == (const char *v) const;
  1086.     int  operator != (const char *v) const;
  1087.     int  operator >  (const char *v) const;
  1088.     int  operator <  (const char *v) const;
  1089.     int  operator >= (const char *v) const;
  1090.     int  operator <= (const char *v) const;
  1091.  
  1092.     int Contains( const FCWString v, const quadnum i );
  1093.  
  1094.     virtual int LengthWOTBlanks();
  1095.  
  1096.   private:
  1097.     void*    pData;
  1098. };
  1099.  
  1100. inline
  1101. int EXPORT DBCS :: operator != (const DBCS& v) const
  1102. {
  1103.    return (!( *this == v ));
  1104. }
  1105.  
  1106. inline
  1107. int EXPORT DBCS :: operator <= (const DBCS& v) const
  1108. {
  1109.    return (!( *this > v ));
  1110. }
  1111.  
  1112. inline
  1113. int EXPORT DBCS :: operator >= (const DBCS& v) const
  1114. {
  1115.    return (!( *this < v ));
  1116. }
  1117.  
  1118. inline
  1119. int EXPORT DBCS :: operator != (const char* v) const
  1120. {
  1121.    return (!( *this == v ));
  1122. }
  1123.  
  1124. inline
  1125. int EXPORT DBCS :: operator <= (const char* v) const
  1126. {
  1127.    return (!( *this > v ));
  1128. }
  1129.  
  1130. inline
  1131. int EXPORT DBCS :: operator >= (const char* v) const
  1132. {
  1133.    return (!( *this < v ));
  1134. }
  1135.  
  1136.  
  1137. /* **********************************************************************/
  1138. /* MIX                                                                  */
  1139. /* **********************************************************************/
  1140.  
  1141. class MIX : public ChaItem
  1142. {
  1143.   public:
  1144.  
  1145.     MIX (Parent&, Level, int, int, int, int);
  1146.     MIX (int, int);
  1147.     MIX (const MIX&, int);
  1148.     MIX (const MIX&, quadnum);
  1149.     virtual ~MIX();
  1150.  
  1151.     MIX operator [] (quadnum) const;
  1152.  
  1153.     void SetEmpty () const;
  1154.     Bool IsNumeric () const;
  1155.     Bool IsBlank();
  1156.  
  1157.                                      /* Interactions with other MIX objects*/
  1158.     void operator =  (const MIX& v);
  1159.     int  operator == (const MIX& v) const;
  1160.     int  operator != (const MIX& v) const;
  1161.     int  operator >  (const MIX& v) const;
  1162.     int  operator <  (const MIX& v) const;
  1163.     int  operator >= (const MIX& v) const;
  1164.     int  operator <= (const MIX& v) const;
  1165.  
  1166.                                        /* Interactions with CHA objects    */
  1167.     friend class CHA;
  1168.     void operator =  (const CHA& v);
  1169.     int  operator == (const CHA& v) const;
  1170.     int  operator != (const CHA& v) const;
  1171.     int  operator >  (const CHA& v) const;
  1172.     int  operator <  (const CHA& v) const;
  1173.     int  operator >= (const CHA& v) const;
  1174.     int  operator <= (const CHA& v) const;
  1175.  
  1176.                                     /* Interactions with character literals*/
  1177.     void operator =  (const char *v);
  1178.     int  operator == (const char *v) const;
  1179.     int  operator != (const char *v) const;
  1180.     int  operator >  (const char *v) const;
  1181.     int  operator <  (const char *v) const;
  1182.     int  operator >= (const char *v) const;
  1183.     int  operator <= (const char *v) const;
  1184.  
  1185.     int Contains( const FCWString v, const quadnum i );
  1186.  
  1187.   private:
  1188.     Bool IsValidNumeric () const;
  1189.     void*    pData;
  1190. };
  1191.  
  1192. inline
  1193. int EXPORT MIX :: operator != (const MIX& v) const
  1194. {
  1195.    return (!( *this == v ));
  1196. }
  1197.  
  1198. inline
  1199. int EXPORT MIX :: operator <= (const MIX& v) const
  1200. {
  1201.    return (!( *this > v ));
  1202. }
  1203.  
  1204. inline
  1205. int EXPORT MIX :: operator >= (const MIX& v) const
  1206. {
  1207.    return (!( *this < v ));
  1208. }
  1209.  
  1210. inline
  1211. int EXPORT MIX :: operator != (const CHA& v) const
  1212. {
  1213.    return (!( *this == v ));
  1214. }
  1215.  
  1216. inline
  1217. int EXPORT MIX :: operator <= (const CHA& v) const
  1218. {
  1219.    return (!( *this > v ));
  1220. }
  1221.  
  1222. inline
  1223. int EXPORT MIX :: operator >= (const CHA& v) const
  1224. {
  1225.    return (!( *this < v ));
  1226. }
  1227.  
  1228. inline
  1229. int EXPORT MIX :: operator != (const char* v) const
  1230. {
  1231.    return (!( *this == v ));
  1232. }
  1233.  
  1234. inline
  1235. int EXPORT MIX :: operator <= (const char* v) const
  1236. {
  1237.    return (!( *this > v ));
  1238. }
  1239.  
  1240. inline
  1241. int EXPORT MIX :: operator >= (const char* v) const
  1242. {
  1243.    return (!( *this < v ));
  1244. }
  1245.  
  1246.  
  1247. // *********************************************************************
  1248. // Stream overloads
  1249. // *********************************************************************
  1250.  
  1251. ostream& operator << (ostream&, quadnum&);
  1252. ostream& operator << (ostream&, const FCWString&);
  1253. ostream& operator << (ostream&, const CHA&);
  1254. ostream& operator << (ostream&, const DBCS&);
  1255. ostream& operator << (ostream&, const MIX&);
  1256. ostream& operator << (ostream&, const HEX&);
  1257. ostream& operator << (ostream&, const BIN2&);
  1258. ostream& operator << (ostream&, const BIN4&);
  1259. ostream& operator << (ostream&, const BIN8&);
  1260. ostream& operator << (ostream&, const NUM&);
  1261. ostream& operator << (ostream&, const NUMC&);
  1262. ostream& operator << (ostream&, const PACK&);
  1263. ostream& operator << (ostream&, const PACF&);
  1264.  
  1265. // *********************************************************************
  1266. // Trace overloads
  1267. // *********************************************************************
  1268.  
  1269. TraceFile& operator << (TraceFile&, quadnum&);
  1270. TraceFile& operator << (TraceFile&, const FCWString&);
  1271. TraceFile& operator << (TraceFile&, const CHA&);
  1272. TraceFile& operator << (TraceFile&, const DBCS&);
  1273. TraceFile& operator << (TraceFile&, const MIX&);
  1274. TraceFile& operator << (TraceFile&, const HEX&);
  1275. TraceFile& operator << (TraceFile&, const BIN2&);
  1276. TraceFile& operator << (TraceFile&, const BIN4&);
  1277. TraceFile& operator << (TraceFile&, const BIN8&);
  1278. TraceFile& operator << (TraceFile&, const NUM&);
  1279. TraceFile& operator << (TraceFile&, const NUMC&);
  1280. TraceFile& operator << (TraceFile&, const PACK&);
  1281. TraceFile& operator << (TraceFile&, const PACF&);
  1282.  
  1283. //  min(a,b) function :  takes quadnums as parameters
  1284. int  Min( const quadnum& a, const quadnum& b );
  1285.  
  1286. #endif
  1287.