/* d4data.hpp (c)Copyright Sequiter Software Inc., 1988-1996.  All rights reserved. */

#ifndef __DATA4HEADER
   #define __DATA4HEADER

#ifdef S4WIN32
   #define _fmemset memset
#endif
#ifdef S4OS2
  #ifdef __BORLANDC__
     #define _fmemset memset
  #endif
#endif

#ifdef S4UNIX
   #define _fmemset memset
//   #define errorCode error_code
//   #define optimizeWrite optimize_write
//   #define sort4assignCmp sort4assign_cmp
#endif

class S4CLASS Data4 ;
class S4CLASS Index4 ;
class S4CLASS Str4len ;
class S4CLASS Str4ptr ;
class S4CLASS Field4info ;
class S4CLASS Tag4info ;
class S4CLASS List4 ;
class S4CLASS File4 ;
class S4CLASS Tag4 ;
class S4CLASS Date4 ;
class S4CLASS Code4 ;
class S4CLASS Str4flex;
class S4CLASS Expr4
{
public:
   EXPR4 S4PTR *expr ;

   Expr4()                     { expr = 0 ; }
   Expr4( EXPR4 S4PTR *ex )    { expr = ex ;}
   Expr4( Data4 d, char *ex );
   #ifdef __TURBOC__
      operator double() const { double d; expr4double2( expr, &d ) ; return d; }
   #else
      operator double() const { return expr4double( expr ) ; }
   #endif
   Data4 data() const;
   void free()                { expr4free( expr ) ; expr = 0 ;}
   // #ifndef S4CLIENT
   //  char *key( ) ;
   // #endif
   //int keyLen()               { return expr4key_len( expr ) ;}
   int len()                  { return expr4len( expr ) ;}
   int parse( Data4 d, char *ex);
   int isValid() const        { return expr != 0  ;  }
   const char S4PTR*source() const  { return expr4source( expr ) ;}
   const char S4PTR*str() {return expr4str(expr);}
   #ifdef S4USE_TRUE
      int true()                 { return expr4true( expr ) ;}
   #else
      int isTrue()               { return expr4true( expr ) ;}
   #endif
   int type()                 { return expr4type( expr ) ;}
   char *vary( ) {char *result; int rc; rc=expr4vary(expr, &result); return result;}
} ;

class S4CLASS Code4 : public CODE4
{
protected:
   MEM4 *string_types[16] ;
   friend class Str4flex ;
public:
   Code4( int initialize = 1 ) { if( initialize ) init() ; }

   Code4( Code4& ) ;         /* Illegal operation, force link error */
   operator =(Code4 &) ;     /* Illegal operation, force link error */

   int   calcCreate( Expr4 ex, char *name )
                               { return (code4calcCreate( this, ex.expr, name )) ? r4success:-1; }
   void  calcReset()           { code4calcReset( this ) ; }
   int   closeAll()            { return code4close( this ) ; }
#ifdef S4CLIENT
   int   connect( S4CONST char *serverId=DEF4SERVER_ID,
                  S4CONST char *processId=DEF4PROCESS_ID,
                  S4CONST char *userName = "PUBLIC",
                  S4CONST char *password = 0,
                  S4CONST char *protocol = (char *)PROT4DEFAULT )
                               { return code4connect( this, serverId, processId, userName, password, protocol ) ; }
#endif
   Data4 data( char *alias );
   const char S4PTR* dateFormat()
                               { return code4dateFormat( this ) ; }
   int   dateFormat( const char *format )
                               { return code4dateFormatSet( this, format ) ; }
   int   error( const int er, const long er2 = 0L, const char *p1=0,
                const char *p2 = 0, const char *p3 = 0 )
                       { return error4describe( this, er, er2, p1, p2, p3 ) ; }
   int errorFile(char *fileName, int overwrite=1)
                    { return error4file(this,fileName,overwrite);}
   int   errorSet(int c=0 ){ return error4set( this, c ) ; }

   const char S4PTR* errorText(const long c )
                               { return error4text( this, c ) ; }
   void  exit()                { code4exit( this ) ; }
   void  exitTest()            { error4exitTest( this ) ; }
   int   flushFiles()          { return code4flush( this ) ; }
   const char S4PTR* indexExtension()
                               { return code4indexExtension( this ) ; }
   inline int   init();
   int   initUndo()            { return code4initUndo( this ) ; }
   int   lock()                { return code4lock( this ) ; }
   void   lockClear()           { code4lockClear( this ) ; }
   const char *lockFileName() {return code4lockFileName(this);}
   long  lockItem()            { return code4lockItem( this ) ; }
   #ifdef S4CLIENT
      const char S4PTR* lockUserId( )
                               { return code4lockUserId( this ) ;}
      const char S4PTR* lockNetworkId( )
                               { return code4lockNetworkId( this ) ; }
   #endif
#ifdef S4SERVER
      const char S4PTR* lockUserId( )
                               { return code4lockUserId( this ) ;}
      const char S4PTR* lockNetworkId( )
                               { return code4lockNetworkId( this ) ; }
   #endif
   #ifdef S4STAND_ALONE
   #ifndef S4OFF_WRITE
   #ifndef S4OFF_TRAN
      int   logCreate( const char *name,const char *userId )
                               { return code4logCreate( this, name,userId ) ; }
      const char S4PTR* logFileName()
                               { return code4logFileName( this ) ; }
      int   logOpen( const char *name, const char *userId )
                               { return code4logOpen( this, name, userId ) ; }
      void   logOpenOff()       { code4logOpenOff( this ) ; }
   #endif
   #endif
   #endif
   int   optAll()  {return code4optAll(this);}
   int   optStart()            { return code4optStart( this ) ; }
   int   optSuspend()          { return code4optSuspend( this ) ; }
   #ifndef S4DLL
      void    reset( )         { mem4reset( ) ;}
   #endif
   long timeout()               {return code4timeout(this);}
   void timeout(long l)         {code4timeoutSet(this,l);}
   int   tranCommit()          { return code4tranCommit( this ) ; }
   int   tranRollback()        { return code4tranRollback( this ) ; }
   int   tranStart()           { return code4tranStart( this ) ; }
   int   tranStatus()          { return  code4tranStatus(this); }
   int   unlock()              { return code4unlock( this ) ; }
   int   unlockAuto()          { return code4unlockAuto( this ) ; }
   int   unlockAuto( int c )   { return code4unlockAutoSet( this, c ) ; }

} ;

class S4CLASS Data4
{
public:
   DATA4 S4PTR *data ;
   Data4()                           { data = 0 ; }
   Data4( DATA4 S4PTR*d )            { data = d ; }
   Data4( Code4& code, char *name )  { data = d4open( &code, name ) ; }
   operator DATA4 *()  const         { return data; }
   const char   S4PTR* alias()             { return d4alias( data ) ; }
   DATA4 S4PTR *dat()                { return data; }
   void    alias(const char S4PTR *ptr)   { d4aliasSet(dat(),ptr) ; }
   int    append()                   { return d4append( data ) ; }
   int    appendBlank()              { return d4appendBlank( data ) ; }
   int    appendStart( int memo = 0 ){ return d4appendStart( data, memo ) ; }
   void    blank()                   {d4blank( data ) ; }
   int    bof()                      { return d4bof( data ) ; }
   int    bottom()                   { return d4bottom( data ) ; }
   int    changed( int flag = -1 )   { return d4changed( data, flag ) ; }
   int    check()                    { return d4check( data ) ; }
   int    close()                    { int rc = d4close( data ) ;
                                       data = 0; return rc; }
   int    create( Code4& code, S4CONST char *name, S4CONST FIELD4INFO &f,
                  S4CONST TAG4INFO &t)
                                     { data = d4create( &code, name, &f, &t ) ;
                                       return code.errorCode ; }
   int    create( Code4& code, S4CONST char *name, S4CONST FIELD4INFO &f)
                                     { data = d4create( &code, name, &f, 0) ;
                                       return code.errorCode ; }
   int    create( Code4& code, S4CONST char *name, S4CONST FIELD4INFO *f,
                  S4CONST TAG4INFO *t = 0 )
                                     { data = d4create( &code, name, f, t ) ;
                                       return code.errorCode ; }
   void    deleteRec()               { d4delete( data ) ; }
   int    deleted()                  { return d4deleted( data ) ; }
   int    eof()                      { return d4eof( data ) ; }
   int    fieldNumber( const char *name)
                                     { return d4fieldNumber( data, name) ; }
   const char S4PTR* fileName()      { return d4fileName( data ) ; }
   int    flush()                    { return d4flush( data ) ; }
   /*  AS - no longer supported (04/23/96)
   #ifndef S4CLIENT
      int flushData()                { return d4flushData( data ) ; }
   #endif
   */
   int    freeBlocks()               { return d4freeBlocks( data ) ; }
   int    go( const long rec )       { return d4go( data, rec ) ; }
   int    goBof()                    { return d4goBof( data ) ; }
   int    goEof()                    { return d4goEof( data ) ; }
   Index4 index( const char *name);
   int    isValid( )                 { return data != 0 ; }
   int    lock( const long rec_num ) { return d4lock( data, rec_num ) ; }
   int    lockAdd( long recnum )     { return d4lockAdd( data, recnum ) ; }
   int    lockAddAppend()            { return d4lockAddAppend( data ) ; }
   int    lockAddFile()              { return d4lockAddFile( data ) ; }
   int    lockAddAll()      {return d4lockAddAll(data);}
   int lockAll()                  { return d4lockAll( data ) ; }

   int    lockAppend()               { return d4lockAppend( data ) ; }
   int    lockFile()                 { return d4lockFile( data ) ; }

/*
 * d4lockTest... functions are no longer available
 *
 * int    lockTest( const long rec ) { return d4lockTest( data, rec ) ; }
 * int    lockTestAppend()           { return d4lockTestAppend( data ) ; }
 * int    lockTestFile()             { return d4lockTestFile( data ) ; }
 * #ifndef S4CLIENT
 *    int lockTestIndex()            { return d4lockTestIndex( data ) ; }
 * #endif
 */

   int    log(int l)                 { return d4log( data, l) ; }
   int    log()                      { return d4log( data, -1 ) ; }
   int    memoCompress()             { return d4memoCompress( data ) ; }
   int    numFields()                { return d4numFields( data ) ; }
   int    open( Code4 &code, S4CONST char *name )
                                     { data =  d4open( &code, name ) ;
                                       return ( code.errorCode < 0 ? code.errorCode : 0 ) ; }
   inline int    openClone( Data4 d );
   int    optimize( const int opt_flag )
                                     { return d4optimize( data, opt_flag ) ; }
   int    optimizeWrite( const int opt_flag )
                                     { return d4optimizeWrite( data,  opt_flag ) ; }
   int    pack()                     { return d4pack( data ) ; }
   #ifdef __TURBOC__
      double position()              { double d; d4position2( data, &d ) ;
                                       return d; }
   #else
      double position()              { return d4position( data ) ; }
   #endif
   int    position( const double pos ){ return d4positionSet( data, pos ) ; }
   void   recall()                   { d4recall( data ) ; }
   long   recCount()                 { return d4recCount( data ) ; }
   long   recNo()                    { return d4recNo( data ) ; }
   char   S4PTR* record()            { return d4record( data ) ; }
   //long   recPosition( const long r ){ return d4recPosition( data, r ) ; }
   unsigned int recWidth()           { return d4recWidth( data ) ; }
   int    refresh()                  { return d4refresh( data ) ; }
   int    refreshRecord()            { return d4refreshRecord( data ) ; }
   int    reindex()                  { return d4reindex( data ) ; }
   int    remove()                   {return d4remove(data);}
   int    seek( S4CONST char *ptr )  { return d4seek( data, ptr ) ; }
   int    seek( S4CONST char *ptr, const int len )
                                     { return d4seekN( data, ptr, len ) ; }
   int    seek( S4CONST double d )   { return d4seekDouble( data, d ) ; }
   #ifndef S4CB51
   int    seekNext( const char *ptr ){ return d4seekNext( data, ptr ) ; }
   int    seekNext( const char *ptr, const int len )
                                     { return d4seekNextN( data, ptr, len ) ; }
   int    seekNext( const double d ) { return d4seekNextDouble( data, d ) ; }
   #endif
   void    select()                   {d4tagSelect( data, 0 ) ; }
   void    select( Tag4 tag ) ;
   void    select( const char *tagName );
   int    skip( const long n = 1 )   { return d4skip( data, n ) ; }
   int    tagSync()                  { return d4tagSync( data, d4tagSelected( data ) ) ; }
   int    top()                      { return d4top( data ) ; }
   int    unlock()                   { return d4unlock( data ) ; }
   int    write( long rec = -1 )     {  return d4write( data,rec);}
   int    zap( long f = 1, long last = 1000000000L)
                                     { return d4zap( data, f, last ) ; }
} ;

class S4CLASS Index4
{
public:
   INDEX4 S4PTR *index ;
public:
   Index4()                          { index = 0 ; }
   Index4( INDEX4 S4PTR *in )        { index = in ; }
   Index4( Data4 d, S4CONST char *name )
                                     { index = i4open( d.dat(), name ) ; }
   int    close()                    { int rc =  i4close( index ) ;
                                       index = 0 ; return rc;}
   int    create( Data4 d, S4CONST char *name, S4CONST TAG4INFO *info )
                                     { index = i4create( d.dat(), name, info ) ;
                                       return d.dat()->codeBase->errorCode ; }
   int    create( Data4 d, S4CONST TAG4INFO *info )
                                     { index = i4create( d.dat(), 0, info ) ;
                                       return d.dat()->codeBase->errorCode ; }
   int    create( Data4 d, S4CONST char *name, S4CONST Tag4info& info );

   int    create( Data4 d, S4CONST Tag4info& info );

   Data4  data()                     { return Data4( index->data ) ; }
   const  char S4PTR* fileName()     { return i4fileName( index ) ; }
   void   init( Data4 d, const char *name )
                                     { index = d4index(d.dat(), name ); }
   int    isValid()                  { return index!=0;}
   int    open( Data4 d, S4CONST char *file = NULL )
                                     { index = i4open( d.dat(), file ) ;
                                       return d.dat()->codeBase->errorCode ; }
   int    reindex()                  { return i4reindex( index ) ; }
   Tag4   tag( char *name );
   int    tagAdd( const TAG4INFO *newTag )
                                     { return i4tagAdd( this->index, newTag ) ; }
} ;

class S4CLASS Tag4
{

public:
   TAG4 S4PTR *tag;
   Tag4()                      { tag = NULL ; }
   Tag4( TAG4 S4PTR *tg )      { tag = tg ; }
   Tag4( Data4 d, const char * const name = NULL )
                               { tag = d4tag( d.dat(), name ) ;}
   operator TAG4*() const      { return tag ; }
   #ifndef S4SERVER
      char S4PTR* alias()      { return t4alias( tag ) ; }
   #else
      char S4PTR* alias()      { return tag->tagFile->alias ; }
   #endif
   #ifdef S4CLIPPER
       int close() {return t4close(tag);}
   #endif
   #ifdef S4NDX
      int close() {return t4close(tag);}
   #endif
   #ifndef S4CLIENT
   int descending() {return tfile4isDescending(tag->tagFile);}
   #endif
   //#ifndef S4SERVER
      const char S4PTR* expr() { return t4expr(tag) ; }
      const char S4PTR* filter()
                               { return t4filter(tag) ; }
   //#else
   //    const char S4PTR* expr() { return tag->tagFile->expr ; }
   //   const char S4PTR* filter()
   //                            { return tag->tagFile->filter ; }
   //#endif
   //Index4 index()              { return Index4(tag->index) ; }
   void   init( Data4 d, const char *name = NULL ) ;
   //void   initDefault( Data4 d ){ tag = d4tagDefault( d.dat() ) ; }
   void   initFirst( Data4 d ) { tag = d4tagNext( d.dat(), NULL ) ; }
   void   initLast( Data4 d )  { tag = d4tagPrev( d.dat(), NULL ) ; }
   void   initNext( )          { if( isValid( ) ) tag = d4tagNext( tag->index->data, tag ) ; }
   void   initPrev( )          { if( isValid( ) ) tag = d4tagPrev( tag->index->data, tag ) ; }
   void   initSelected( Data4 d )
                               { tag = d4tagSelected( d.dat() ) ; }
   int    isValid()            { return tag!=0; } ;
   #ifdef N4OTHER
      // open() is only supported for N4OTHER
      void    open( Data4 d, char *name )
                                  { tag = t4open( d.dat(), NULL, name ); }
      void    open( Data4 d, Index4 i, char *name )
                                  { tag = t4open( d.dat(), i.index, name) ; }
   #endif
   int    unique()             { return t4unique( tag ) ; }
   int    unique( const int unique_code )
                               { return t4uniqueSet( tag, unique_code ) ; }
} ;

class S4CLASS Str4len ;

class S4CLASS Str4
{
public:
   #ifdef __ZTC__
      virtual operator char() ;
      virtual operator double() ;
      virtual operator int() ;
   #else
      operator char() ;
      operator double() ;
      operator int() ;
   #endif
   virtual operator long() ;
   char& operator[]( int index ) ;
   int  operator==( Str4& ) ;  /* Equal, including length */
   int  operator!=( Str4& s ) { return ! operator==(s) ; }
   int  operator< ( Str4& ) ;
   int  operator> ( Str4& ) ;
   int  operator>=( Str4& s ) { return ! operator<(s) ; }
   int  operator<=( Str4& s ) { return ! operator>(s) ; }
   int  add( Str4& ) ;
   int  add( char *) ;
   int  assign( const char S4PTR * ) ;
   int  assign( const char S4PTR *ptr,const unsigned ptr_len ) ;
   int  assign( const Str4& str_from ) ;
   void assignDouble( double, int new_len = -1, int n_dec = -1 ) ;
   void assignLong( long, int new_len = -1, int zeros_in_front = 0 ) ;
   int  at( Str4& ) ;
   int  encode( char *, char *, char * ) ;
   char *endPtr() ;
   int  insert( Str4&, unsigned pos= 0 ) ;
   void lower() ;
   unsigned ncpy( char *to_ptr, unsigned to_len ) ;
   int  replace( Str4&, unsigned pos= 0 ) ;
   void set( int chr_value ) ;
   void trim() ;
   void upper() ;

   /* Get information */
   const Str4len left( unsigned l ) const;
   const Str4len right( unsigned l ) const;
   const Str4len substr( unsigned pos, unsigned result_len ) const;
   #ifdef S4USE_TRUE
      int true() ;
   #else
      int isTrue() ;
   #endif
   virtual void      changed()          {}
   virtual int       decimals()         { return 0 ; }
   virtual unsigned  len() ;
   virtual unsigned len1() const;
   #ifndef S4OFF_ENFORCE_LOCK
      // Returns r4success if its ok, otherwise returns -1
      virtual int    lockCheck()        { return r4success ; }
   #endif
   virtual unsigned  maximum()         { return len() ; }
   virtual char      S4PTR*ptr()  = 0 ;
   virtual const char      S4PTR*ptr1() const  = 0 ;
   virtual const char      S4PTR*str() ;
   virtual int       setLen(unsigned)  { return -1 ; }
   virtual int       setMax(unsigned)  { return -1 ; }

} ;

class S4CLASS Str4char : public Str4
{
public:
   Str4char( char ch = 0 ) ;
   char     S4PTR*ptr()       { return &c ; }
   char     const S4PTR*ptr1() const      { return &c ; }
   unsigned len()             { return 1 ; }
   unsigned len1() const             { return 1 ; }

private:
   char c ;
} ;

class S4CLASS Str4ptr : public Str4
{
public:
   Str4ptr( char *ptr )        { p =   ptr ; }
   char S4PTR*ptr()             { return p ; }
   char const S4PTR*ptr1() const             { return p ; }
   char *p ;
} ;

class S4CLASS Str4len : public Str4ptr
{
public:
   Str4len( const void *ptr, unsigned ptr_len ) : Str4ptr((char *)ptr)
                               { curLen =  ptr_len; }
   unsigned len()              { return curLen ; }
   unsigned len1() const              { return curLen ; }
   unsigned curLen ;
} ;

class S4CLASS Str4max : public Str4len
{
public:
   Str4max( void *ptr, unsigned m ) : Str4len(ptr,m)
                               { maxLen = m; }

   unsigned maximum()          { return maxLen ; }
   int      setLen( unsigned) ;

   unsigned maxLen ;

} ;

/* The following classes  are always guaranteed to be null ended. */
class S4CLASS Str4ten : public Str4
{
public:
   Str4ten()                   { curLen = 0; buf[0] = 0; buf[10] = 0; }
   Str4ten( const char *p )    { curLen = 0; buf[10] = 0; assign(p); }
   Str4ten( Str4 &s )          { curLen = 0; buf[10]=0; assign(s); }

   unsigned len()              { return curLen; }
   unsigned len1() const             { return curLen; }
   unsigned maximum()          { return 10 ; }
   char     S4PTR*ptr()        { return buf ; }
   char    const S4PTR*ptr1() const       { return buf ; }
   int      setLen(unsigned new_len) ;

   unsigned curLen ;

private:
   char buf[12] ;
} ;

class S4CLASS Str4large: public Str4
{
public:
   Str4large() ;
   Str4large( char *p );
   Str4large( Str4 &s) ;

   unsigned maximum()     { return 255 ; }
   unsigned len()     { return curLen; }
   unsigned len1() const    { return curLen; }
   char    S4PTR*ptr()      { return buf ; }
   char    const S4PTR*ptr1() const     { return buf ; }
   int      setLen(unsigned len) ;

   unsigned curLen ;

private:
   char buf[256] ;
} ;

class S4CLASS Str4flex : public Str4max
{
public:
   Str4flex( Code4 & ) ;
   Str4flex( Str4flex& ) ;
  ~Str4flex() ;
   Str4flex &operator =( Str4flex &s )
                               { assign( s ) ; return s ;}

   void   free() ;
   int    setMax( unsigned ) ;
   const char   S4PTR*str()          { return ptr() ; }

   Code4 S4PTR *codeBase ;

} ;

class S4CLASS Field4 : public Str4
{
public:
   Field4()                      { field =  0 ; }
   Field4( Data4 d, int j )      { field =  d4fieldJ( d.dat(), j ) ; }
   Field4( Data4 d, const char *name ) { field =  d4field( d.dat(), name ) ; }
   Field4( FIELD4 *f )           { field =  f ; }

   void          assignField( Field4 f ) { f4assignField( field, f.field ) ; }
   void          changed()   { d4changed(field->data, 1) ; }
   Data4         data()      { return Data4( field->data ) ; }
   int           decimals()  { return f4decimals(field) ; }
   int           init( Data4 d, const char *name )
                             { field = d4field( d.dat(), name ) ;
                               return (field == 0) ? -1 : 0 ; }
   int           init( Data4 d, int j )
                             { field = d4fieldJ( d.dat(), j ) ;
                               return (field == 0) ? -1 : 0 ; }
   int           isValid() { return field!=0;}
   unsigned      len()       { return f4len(field) ; }
   unsigned      len1() const       { return f4len(field) ; }
#ifndef S4OFF_ENFORCE_LOCK
   int            lockCheck();
#endif
   const char         S4PTR*name()      { return f4name(field) ; }
   int           number()    { return d4fieldNumber( field->data, name() ) ;}
   int           type()      { return f4type(field) ; }
   char         S4PTR*ptr()        { return f4ptr(field) ; }
   char   const S4PTR*ptr1() const        { return f4ptr(field) ; }

   FIELD4    S4PTR *field ;
} ;

class S4CLASS Field4info
{
public:
   Field4info( Code4 &) ;
   Field4info( Data4  ) ;

   ~Field4info() ;
   Field4info( Field4info &);  // Illegal operation, force link error
   operator =(Field4info&) ;   // Illegal operation, force link error
   int add( const char *, char , int len = 0, int dec = 0 ); //in f4info_p.cpp
   int add( Field4 ) ;
   int add( Data4 ) ;
   int del( int ) ;
   int del( char *) ;
   void free( ) ;
   FIELD4INFO *fields( ) { return field ;}
   const FIELD4INFO *operator[](int index) ;
   int numFields() { return size ; } ;
private:
   Code4 S4PTR *codeBase ;
   FIELD4INFO *field ;
   int size ;
   unsigned length ;
} ;

class S4CLASS Tag4info
{
private:
   char *expr, *filt;
public:
   Tag4info( Code4 &) ;
   Tag4info( Data4 ) ;
   Tag4info( Index4 ) ;
   ~Tag4info() ;
   Tag4info(Tag4info&) ;    // Illegal action, force a link error
   operator =( Tag4info &) ;  // Illegal action, force a link error

   int  add( const char *, const char *, const char *filter = NULL, int uniq = 0, int desc = 0 );
   int  add( Tag4 ) ;
   int  del( int ) ;
   int  del( const char * ) ;
   TAG4INFO * tags( ) { return tag ; }
   void free( ) ;
   int  numTags() { return size ; } ;
private:
   int  add_index_tags( INDEX4 * ) ;
   char S4PTR* getName( TAG4INFO *tagInfo, int tagPos = 0 ) ;
   const char S4PTR* getExpr( TAG4INFO *tagInfo, int tagPos = 0 ) ;
   const char S4PTR* getFilter( TAG4INFO *tagInfo, int tagPos = 0 ) ;
   int  getUniqueKey( TAG4INFO *tagInfo, int tagPos = 0 ) ;
   int  getDescendKey( TAG4INFO *tagInfo, int tagPos = 0 ) ;
   Code4 S4PTR *codeBase ;
   TAG4INFO *tag ;
   int size ;
   unsigned length ;
   friend class Data4 ;
   friend class Index4 ;
} ;

class S4CLASS Field4memo : public Field4
{
public:
   Field4memo() ;
   Field4memo( Data4& data, int j ) ;
   Field4memo( Data4& data, const char *name ) ;
   Field4memo( Field4 f ) ;

   void changed() ;
   void free()       { f4memoFree(field) ; }
   unsigned len()    { return f4memoLen(field) ; }
   unsigned len1() const   { return f4memoLen(field) ; }
   int  setLen(unsigned new_len) ;

   char S4PTR*ptr()        { return f4memoPtr(field) ; }
   char const S4PTR*ptr1() const       { return f4memoPtr(field) ; }
   const char S4PTR*str()       { return f4memoStr(field) ; }

} ;

class S4CLASS  Date4 : public Str4
{
public:
   Date4() ;
   Date4( long l ) ;
   Date4( const char S4PTR* p) ;
   Date4( char S4PTR* p, char S4PTR* pict ) ;
   operator long()         { return date4long(ptr()) ; }
   #ifdef __TURBOC__
      operator double()    { double d;
                                  date4formatMdx2( ptr(), &d );
                                  return d; }
   #else
      operator double()    { return date4formatMdx( ptr() ); }
   #endif

   long operator  +( const long l )    { return (date4long(ptr())+l) ; }
   long operator  -( const long l )    { return (date4long(ptr())-l) ; }
   void operator +=( const long l)     { date4assign( ptr(), date4long(ptr())+l ) ; }
   void operator -=( const long l )    { date4assign( ptr(), date4long(ptr())-l ) ; }
   long operator ++( )                 { *this+=1L ; return long(*this) ; }
   long operator ++( int i)            { *this+=1L ; return long(*this)-1L ; }
   long operator --( )                 { *this-=1L ; return long(*this) ; }
   long operator --(int i)             { *this-=1L ; return long(*this)+1L ; }
   void   assign( const long l)        { date4assign(ptr(),l) ; }
   void   assign( const char *p )      { u4ncpy( ptr(), p, sizeof(dt) ) ; }
   void   assign( const char *p, char *pict )
                                       { date4init( ptr(), p, pict) ; }
   void   assign( Str4 &s)             { Str4::assign(s) ; }
   const char   S4PTR* cdow()          { return date4cdow( ptr() ) ; }
   const char   S4PTR* cmonth()        { return date4cmonth(ptr()) ; }
   int    day()                        { return date4day(ptr()) ; }    /* Day of month  (1-31) */
   int    dow()                        { return date4dow(ptr()) ; }    /* Day of week   (1-7) */
   void   format( char *result, char *pict )
                                       { date4format( ptr(), result, pict ) ; }
   char  *format( char *pict ) const ;
   int    isLeap() const               { long y = date4year(dt) ;
                                         return (y%4 == 0 && y%100 != 0 || y%400 == 0) ?  1 : 0 ; }
   unsigned len()                  { return 8 ; }
   unsigned len1() const                { return 8 ; }
   int    month()                      { return date4month(ptr()) ; }/* Month of year (1-12) */
   void   today()                      { date4today(ptr()) ; }
   int    year()                       { return date4year(ptr()) ; } ;
   //const char *str()
   char S4PTR*ptr()                    { return  dt ; }
   char const S4PTR*ptr1() const                    { return  dt ; }

private:
   char dt[9] ;
} ;


class S4CLASS File4 : public FILE4
{
public:
   File4() { hand = -1 ; }
   File4( Code4 &code, char *namestr, int do_alloc = 0 )
                               { open( code, namestr, do_alloc ) ;}
   File4( File4& ) ;             /* Illegal operation, force link error */

   int close()                 { return file4close( this ) ; }
   int create( Code4 &code, char *namestr, const int do_alloc = 0 )
                               { return file4create( this, &code, namestr, do_alloc ) ; }

   //const char S4PTR*fileName() { return name ;}
   int flush()                 { return file4flush( this ) ;}
   int isValid( ) const        { return ( hand >= 0 ) ? 1 : 0 ;}
   long len()                  { return file4len( this ) ; }
   long len1()                 { return file4len( this ) ; }
   int setLen( const long l)   { return file4lenSet( this, l ) ; }
   int lock( const long start, const long bytes )
                               { return file4lock( this, start, bytes); }
   const char S4PTR*fileName() const {return name;}
   int open( Code4 &code, S4CONST char *namestr, const int do_alloc = 0 )
                               { return file4open( this, &code, namestr, do_alloc ) ; }
   int optimize( const int opt_flag, const int file_type )
                               { return file4optimize( this, opt_flag, file_type ) ;}
   int optimizeWrite( const int opt_flag )
                               { return file4optimizeWrite( this, opt_flag ) ; }
   unsigned read( const long pos, void *ptr, const unsigned len )
                               { return file4read( this, pos, ptr, len ) ; }
   unsigned read( const long pos, Str4 &string )
                               { return read( pos, (void *)string.ptr(), string.len());}
   unsigned readAll( const long pos, void *ptr, const unsigned len )
                               { return file4readAll( this, pos, ptr, len) ;  }
   unsigned readAll( const long pos, Str4 &string )
                               { return readAll( pos, (void *)string.ptr(), string.len() ) ;}
   int refresh()               { return file4refresh( this ) ; }
   int replace( File4 &new_file )
                               { return file4replace( this, &new_file ) ;}
   //int setLen (const long newLen) {return file4setLen(this, newLen);}
   int unlock( long pos_start, long num_bytes )
                               { return file4unlock (this, pos_start, num_bytes) ; }
   int write( const long pos, const void S4PTR* ptr, const unsigned len )
                               { return file4write( this, pos, ptr, len ) ;  }
   int write( const long pos, const char *nullended )
                               { return write( pos, nullended, strlen(nullended) ) ; }
   int write( const long pos, Str4 &s )
                               { return write( pos, (void *)s.ptr( ), s.len( ) ) ;}
} ;

class S4CLASS File4seqRead : public FILE4SEQ_READ
{
public:

   File4seqRead( File4 &f, const long start_pos, void *buf, const unsigned buf_len )
                               { file4seqReadInit( this, &f, start_pos, buf, buf_len ) ;}
   File4seqRead() {}

   File4seqRead& operator>>( Str4 &string) { read(string); return *this;}

   void init( File4 &f, long start_pos, void *buf, const unsigned buf_len )
                               { file4seqReadInit( this, &f, start_pos, buf, buf_len ) ;}
   unsigned read( void *ptr, const unsigned len )
                    { return file4seqRead( this, ptr, len ) ; }
   unsigned read( Str4 &s )
                    { return file4seqRead( this, s.ptr(), s.len());}
   int readAll( void *ptr, const unsigned len )
                    { return file4seqReadAll( this, ptr, len);}
   int readAll( Str4 &s )
                    { return file4seqReadAll( this, s.ptr(), s.len());}
} ;

class S4CLASS File4seqWrite : public FILE4SEQ_WRITE
{
public:
   File4seqWrite( File4 &f, const long start_pos, void *buf, const unsigned buf_len )
                               { file4seqWriteInit( this, &f, start_pos, buf, buf_len ) ; }
   File4seqWrite() {}
   File4seqWrite &operator<<( Str4 &buf)
                               { write( buf ) ; return *this ;}
   File4seqWrite &operator<<( const long  l) {char t[256];
                                              c4ltoa45(l, t, 9);
                                              t[9] = '\0';
                                              write(t);
                                              return *this;}
   File4seqWrite &operator<<( const char *buf )
                               { write( buf, strlen(buf)); return *this ;}

   void init( File4 &f, const long start_pos, void *buf, const unsigned buf_len )
                               { file4seqWriteInit( this, &f, start_pos, buf, buf_len ) ; }
   int flush()                 { return file4seqWriteFlush( this ); }
   int repeat( const long num_repeat, const char ch )
                               { return file4seqWriteRepeat( this, num_repeat, ch);}
   int write( const void *info, const unsigned info_len )
                               { return file4seqWrite( this, info, info_len ) ;}
   int write( const char *info )
                               { return file4seqWrite( this, info, strlen(info));}
   int write( Str4 &s )
                               { return file4seqWrite( this, s.ptr(), s.len()) ;}
} ;

class S4CLASS List4 : public LIST4
{
public:
   List4()                     { init() ; }
   List4( List4 &) ;             // illegal operation, force link error
   operator =( List4 &);         // illegal operation, force link error

   void *add( void *item )     { l4add( this, item ) ;return item ;}
   void *addAfter( void *anchor, void *item )
                               { l4addAfter( this, anchor, item ) ; return item; }
   void *addBefore( void *anchor, void *item )
                               { l4addBefore( this, anchor, item ) ; return item;}
   void S4PTR*first()          { return l4first( this ) ;}
   void S4PTR*last()           { return l4last(this) ;}
   void S4PTR*next( void *item = NULL )
                               { return l4next( this, item ) ;}
   int   numNodes()            { return nLink ; }
   void S4PTR*pop()            { return l4pop( this ) ;}
   void S4PTR*prev( void *item){ return l4prev( this, item ) ; }
   void remove( void *item )   { l4remove( this, item ) ; }
   void init()                { lastNode = 0 ; nLink = 0 ; }
} ;

class S4CLASS Sort4 : public SORT4
{
public:
   Sort4() {} ;
   Sort4( Code4 &code, int sort_len, int other_len = 0 )
         { sort4init( this, &code, sort_len, other_len ) ;}
   Sort4( Sort4 &) ;      // Illegal operation, force link error
   operator =( Sort4&) ;  // Illegal operation, force link error
   void *result, *resultOther ;
   long  resultRec ;

 //  #ifdef S4WINDOWS
 //    #ifndef _MSC_VER
 //   #ifndef STRICT
 //     void assignCmp(S4CMP_FUNCTION *f) { sort4assignCmp( this, f ) ;}
 // #endif
 //#endif
 //#else
//   void assignCmp(int *f) { *f=0;}
     void assignCmp(S4CMP_FUNCTION_PTR f) { sort4assignCmp( this, f ) ;}
   //{ sort4assignCmp( this, f ) ;}
 //#endif
   int free() { return sort4free( this ) ;}
   int get() { return sort4get( this, &resultRec, (void S4PTR*S4PTR*)&result, (void S4PTR*S4PTR*)&resultOther ) ;}
   int getInit() { return sort4getInit( this ) ;}
   int init( Code4 &code, int sort_len, int other_len = 0 )
         { return sort4init( this, &code, sort_len, other_len ) ;}
   int put( void *sort_info, void *other_info = NULL, long rec = 0L )
         { return sort4put( this, rec, sort_info, other_info ) ;}

};

class S4CLASS Mem4
{
public:
   Mem4() { mem = 0; }
   Mem4( Code4 &code, int start, int size, int expand, int temp = 1 )
          { mem = mem4create( &code, start, size, expand, temp ) ;}
   Mem4( MEM4 S4PTR *m ) { this->mem = m ; }
   MEM4 S4PTR *mem ;
   void S4PTR*alloc()  { return mem4alloc( mem ) ;}
   int  create( Code4 &code, int units_start, int unit_size, int units_expand, int make_temp = 1 )
          { mem = mem4create( &code, units_start, unit_size, units_expand, make_temp ) ;
            return (mem==0) ? -1 : 0; }
   void free( void *ptr ) { mem4free( mem, ptr ) ;}
   int isValid( ) { return mem!=0 ;}
   void release() { mem4release(mem) ;}
} ;

class S4CLASS Relate4
{
public:
   Relate4() { relate = 0 ; }
   Relate4( Relate4 master, Data4 slave, char *m_expr, Tag4 t )
            { relate = relate4createSlave( master.relate, slave.dat(),m_expr, t.tag ) ; }
   Relate4( RELATE4 S4PTR *r ) { relate = r ; }
   Data4 data( ) { return (relate) ? Data4((DATA4 *)relate->data) : Data4((DATA4 *)NULL);}
   Tag4 dataTag( ) { return (relate) ? Tag4((TAG4 *)relate->dataTag) : Tag4((TAG4 *)NULL);}
   int doOne( )         { return relate4doOne( relate ) ; }
   int errorAction( int a ) { return relate4errorAction( relate, a ) ; }
   int init( Relate4 master, Data4 slave, char *m_expr, Tag4 t )
                    { relate = relate4createSlave( master.relate, slave.dat(), m_expr, t.tag ) ;
                      return slave.dat()->codeBase->errorCode ; }

   int isValid() { return relate != NULL ; }

   Relate4 master() { return (relate) ? Relate4((RELATE4 *)relate->master):Relate4((RELATE4 *)NULL) ;}

   #ifndef S4CB51
      const char S4PTR *masterExpr() { return relate4masterExpr(relate) ; }
   #endif

   //Expr4 masterExpr() { return (relate)?Expr4((EXPR4 *)relate->masterExpr):Expr4((EXPR4 *)NULL);}

   int matchLen( int p ) { return relate4matchLen( relate, p ) ;}
   int type( int p )    { return relate4type( relate, p ) ; }

   RELATE4 S4PTR *relate ;
} ;

class S4CLASS Relate4iterator : public Relate4
{
public:
  Relate4iterator() {relate=0;}
  Relate4iterator(class Relate4 r) {relate=r.relate;}
  int next() {return relate4next(&relate) !=2;}
  int nextPosition() {return relate4next(&relate);}
} ;


class S4CLASS Relate4set:public Relate4
{
public:
   Relate4set( Data4 data) { relate = relate4init( data.dat() ) ; }
   Relate4set()          {relate = 0;}
   Relate4set( RELATE4 S4PTR *r ) { relate = r ; }

   int bottom()              { return relate4bottom( relate ) ; }
   void changed()            { relate4changed( relate ) ; }
   int doAll()              { return relate4doAll( relate ) ; }
   int eof()                 { return relate4eof( relate ) ; }
   int free( int p = 0 )     { int rc = relate4free( relate, p ) ; relate = 0; return rc; }
   int init( Data4 data )   { relate = relate4init( data.dat() ) ; return data.dat()->codeBase->errorCode ; }
   int lockAdd()                { return relate4lockAdd( relate ) ; }
   #ifndef S4CB51
      int optimizeable()      { return relate4optimizeable( relate ) ; }
   #endif
   int querySet( char *p = NULL )  { return relate4querySet( relate, p ) ; }
   int skip( long l = 1)     { return relate4skip( relate, l ) ; }
   int skipEnable( int do_enable = 1 ) { return relate4skipEnable(relate,do_enable);}
   int sortSet(const char *sort=NULL) {return relate4sortSet(relate, sort);}
   int top() {return relate4top(relate);}
} ;


#ifdef S4CLIENT
inline int Code4::init( void )
{
   int rc = code4initLow( this,DEF4PROTOCOL,S4VERSION ) ;
   _fmemset( string_types, 0, sizeof(string_types) ) ;
   return rc ;
}
#else
inline int Code4::init( void )
{
    int rc = code4initLow( this,0,S4VERSION ) ;
    _fmemset( string_types, 0, sizeof(string_types) ) ;
    return rc ;
}
#endif

inline Data4 Code4::data( char *alias )
{
  Data4 r;
  r.data=code4data(this,alias);
  return r;
}

inline int   Data4::openClone( Data4 d )
{
   data=d4openClone(d.dat());
   return data->codeBase->errorCode;
}

inline Expr4::Expr4(Data4 d, char *ex)
{
   expr=expr4parse(d.dat(),ex);
}

inline Data4 Expr4::data()const
{
   return Data4( expr->data ) ;
}

inline Tag4 Index4::tag( char *name )
{
  Tag4 t;
  t.tag=i4tag(index,name);
  return t;
}

inline int Index4::create( Data4 d, S4CONST Tag4info& info )
{
  index = i4create( d.dat(), 0, info.tag ) ;
  return d.dat()->codeBase->errorCode ;
}

inline int Expr4::parse( Data4 d, char *ex )
{
   #ifdef E4DEBUG
      if( expr )
         error4( d.dat()->codeBase, e4info, E60601 ) ;
   #endif
   expr = expr4parse( d.dat(), ex ) ;
   return d.dat()->codeBase->errorCode ;
}

inline Index4 Data4::index( const char *name=NULL )
{
   return Index4( d4index(data, name)) ;
}

inline void Data4::select( Tag4 tag )
{
   d4tagSelect( data, tag.tag ) ;
   return;
}

inline void Data4::select( const char *tagName )
{
   if( tagName != NULL )
   {
      TAG4 *tag = d4tag( data, tagName ) ;
      d4tagSelect( data, tag ) ;
      return;
   }
   d4tagSelect( data, NULL ) ;
   return;
}


inline int    Index4::create( Data4 d, S4CONST char *name, S4CONST Tag4info& info )
  { index = i4create( d.dat(), name, info.tag ) ;
  return d.dat()->codeBase->errorCode ; }

inline int Field4memo::setLen( unsigned new_len )
{
   #ifdef S4OFF_MEMO
      return e4notMemo ;
   #else
      #ifdef S4OFF_WRITE
         return e4notWrite ;
      #else
         int rc ;
         char *buf = 0 ;

         if( field->memo == 0 )
            return -1 ;

         if( new_len > field->memo->lenMax )
         {
            buf = (char *) u4allocFree( (CODE4 *) field->data->codeBase, new_len ) ;
            memcpy( buf, field->memo->contents, field->memo->lenMax ) ;
         }
         rc = f4memoSetLen(field,new_len) ;
         if( buf != 0 )
         {
            memcpy( field->memo->contents, buf, field->memo->lenMax ) ;
            u4free( buf ) ;
         }
         return rc ;
      #endif
   #endif
}

#ifndef S4OFF_REPORT
REPORT4 * S4FUNCTION  report4retrieve(Code4 &cb, char *file_name,
                      int open_files, char *pathname);
RELATE4 * S4FUNCTION relate4retrieve( Code4 &cb, char *file_name,
                      int open_files, char *pathname);
int S4FUNCTION relate4save(Relate4set &relSet, char *file_name,
                      int save_paths);
#endif /* NOT S4OFF_REPORT */
#endif /* __DATA4HEADER */