{  File file;  int	rc_seek,error,inited;  uint	rc_length,read_length,reclength;  my_off_t rc_record_pos,end_of_file;  byte	*rc_buff,*rc_buff2,*rc_pos,*rc_end,*rc_request_pos;#ifdef HAVE_AIOWAIT  int	use_async_io;  my_aio_result aio_result;#endif  enum cache_type type;} RECORD_CACHE;enum file_type{  UNOPEN = 0, FILE_BY_OPEN, FILE_BY_CREATE, STREAM_BY_FOPEN, STREAM_BY_FDOPEN,  FILE_BY_MKSTEMP, FILE_BY_DUP};struct st_my_file_info{  my_string		name;  enum file_type	type;#if defined(THREAD) && !defined(HAVE_PREAD)  pthread_mutex_t	mutex;#endif};extern struct st_my_file_info *my_file_info;typedef struct st_my_tmpdir{  char **list;  uint cur, max;#ifdef THREAD  pthread_mutex_t mutex;#endif} MY_TMPDIR;typedef struct st_dynamic_array{  char *buffer;  uint elements,max_element;  uint alloc_increment;  uint size_of_element;} DYNAMIC_ARRAY;typedef struct st_dynamic_string{  char *str;  uint length,max_length,alloc_increment;} DYNAMIC_STRING;struct st_io_cache;typedef int (*IO_CACHE_CALLBACK)(struct st_io_cache*);#ifdef THREADtypedef struct st_io_cache_share{  /* to sync on reads into buffer */  pthread_mutex_t mutex;  pthread_cond_t  cond;  int             count, total;  /* actual IO_CACHE that filled the buffer */  struct st_io_cache *active;#ifdef NOT_YET_IMPLEMENTED  /* whether the structure should be free'd */  my_bool alloced;#endif} IO_CACHE_SHARE;#endiftypedef struct st_io_cache		/* Used when cacheing files */{  /* Offset in file corresponding to the first byte of byte* buffer. */  my_off_t pos_in_file;  /*    The offset of end of file for READ_CACHE and WRITE_CACHE.    For SEQ_READ_APPEND it the maximum of the actual end of file and    the position represented by read_end.  */  my_off_t end_of_file;  /* Points to current read position in the buffer */  byte	*read_pos;  /* the non-inclusive boundary in the buffer for the currently valid read */  byte  *read_end;  byte  *buffer;				/* The read buffer */  /* Used in ASYNC_IO */  byte  *request_pos;  /* Only used in WRITE caches and in SEQ_READ_APPEND to buffer writes */  byte  *write_buffer;  /*    Only used in SEQ_READ_APPEND, and points to the current read position    in the write buffer. Note that reads in SEQ_READ_APPEND caches can    happen from both read buffer (byte* buffer) and write buffer    (byte* write_buffer).  */  byte *append_read_pos;  /* Points to current write position in the write buffer */  byte *write_pos;  /* The non-inclusive boundary of the valid write area */  byte *write_end;  /*    Current_pos and current_end are convenience variables used by    my_b_tell() and other routines that need to know the current offset    current_pos points to &write_pos, and current_end to &write_end in a    WRITE_CACHE, and &read_pos and &read_end respectively otherwise  */  byte  **current_pos, **current_end;#ifdef THREAD  /*    The lock is for append buffer used in SEQ_READ_APPEND cache    need mutex copying from append buffer to read buffer.  */  pthread_mutex_t append_buffer_lock;  /*    The following is used when several threads are reading the    same file in parallel. They are synchronized on disk    accesses reading the cached part of the file asynchronously.    It should be set to NULL to disable the feature.  Only    READ_CACHE mode is supported.  */  IO_CACHE_SHARE *share;#endif  /*    A caller will use my_b_read() macro to read from the cache    if the data is already in cache, it will be simply copied with    memcpy() and internal variables will be accordinging updated with    no functions invoked. However, if the data is not fully in the cache,    my_b_read() will call read_function to fetch the data. read_function    must never be invoked directly.  */  int (*read_function)(struct st_io_cache *,byte *,uint);  /*    Same idea as in the case of read_function, except my_b_write() needs to    be replaced with my_b_append() for a SEQ_READ_APPEND cache  */  int (*write_function)(struct st_io_cache *,const byte *,uint);  /*    Specifies the type of the cache. Depending on the type of the cache    certain operations might not be available and yield unpredicatable    results. Details to be documented later  */  enum cache_type type;  /*    Callbacks when the actual read I/O happens. These were added and    are currently used for binary logging of LOAD DATA INFILE - when a    block is read from the file, we create a block create/append event, and    when IO_CACHE is closed, we create an end event. These functions could,    of course be used for other things  */  IO_CACHE_CALLBACK pre_read;  IO_CACHE_CALLBACK post_read;  IO_CACHE_CALLBACK pre_close;  /*    Counts the number of times, when we were forced to use disk. We use it to    increase the binlog_cache_disk_use status variable.  */  ulong disk_writes;  void* arg;				/* for use by pre/post_read */  char *file_name;			/* if used with 'open_cached_file' */  char *dir,*prefix;  File file; /* file descriptor */  /*    seek_not_done is set by my_b_seek() to inform the upcoming read/write    operation that a seek needs to be preformed prior to the actual I/O    error is 0 if the cache operation was successful, -1 if there was a    "hard" error, and the actual number of I/O-ed bytes if the read/write was    partial.  */  int	seek_not_done,error;  /* buffer_length is memory size allocated for buffer or write_buffer */  uint	buffer_length;  /* read_length is the same as buffer_length except when we use async io */  uint  read_length;  myf	myflags;			/* Flags used to my_read/my_write */  /*    alloced_buffer is 1 if the buffer was allocated by init_io_cache() and    0 if it was supplied by the user.    Currently READ_NET is the only one that will use a buffer allocated    somewhere else  */  my_bool alloced_buffer;#ifdef HAVE_AIOWAIT  /*    As inidicated by ifdef, this is for async I/O, which is not currently    used (because it's not reliable on all systems)  */  uint inited;  my_off_t aio_read_pos;  my_aio_result aio_result;#endif} IO_CACHE;typedef int (*qsort2_cmp)(const void *, const void *, const void *);	/* defines for mf_iocache */	/* Test if buffer is inited */#define my_b_clear(info) (info)->buffer=0#define my_b_inited(info) (info)->buffer#define my_b_EOF INT_MIN#define my_b_read(info,Buffer,Count) \  ((info)->read_pos + (Count) <= (info)->read_end ?\   (memcpy(Buffer,(info)->read_pos,(size_t) (Count)), \    ((info)->read_pos+=(Count)),0) :\   (*(info)->read_function)((info),Buffer,Count))#define my_b_write(info,Buffer,Count) \ ((info)->write_pos + (Count) <=(info)->write_end ?\  (memcpy((info)->write_pos, (Buffer), (size_t)(Count)),\   ((info)->write_pos+=(Count)),0) : \   (*(info)->write_function)((info),(Buffer),(Count)))#define my_b_get(info) \  ((info)->read_pos != (info)->read_end ?\   ((info)->read_pos++, (int) (uchar) (info)->read_pos[-1]) :\   _my_b_get(info))	/* my_b_write_byte dosn't have any err-check */#define my_b_write_byte(info,chr) \  (((info)->write_pos < (info)->write_end) ?\   ((*(info)->write_pos++)=(chr)) :\   (_my_b_write(info,0,0) , ((*(info)->write_pos++)=(chr))))#define my_b_fill_cache(info) \  (((info)->read_end=(info)->read_pos),(*(info)->read_function)(info,0,0))#define my_b_tell(info) ((info)->pos_in_file + \			 (uint) (*(info)->current_pos - (info)->request_pos))/* tell write offset in the SEQ_APPEND cache */my_off_t my_b_append_tell(IO_CACHE* info);#define my_b_bytes_in_cache(info) (uint) (*(info)->current_end - \					  *(info)->current_pos)typedef uint32 ha_checksum;#include <my_alloc.h>	/* Prototypes for mysys and my_func functions */extern int my_copy(const char *from,const char *to,myf MyFlags);extern int my_append(const char *from,const char *to,myf MyFlags);extern int my_delete(const char *name,myf MyFlags);extern int my_getwd(my_string buf,uint size,myf MyFlags);extern int my_setwd(const char *dir,myf MyFlags);extern int my_lock(File fd,int op,my_off_t start, my_off_t length,myf MyFlags);extern gptr my_once_alloc(uint Size,myf MyFlags);extern void my_once_free(void);extern char *my_once_strdup(const char *src,myf myflags);extern char *my_once_memdup(const char *src, uint len, myf myflags);extern my_string my_tempnam(const char *dir,const char *pfx,myf MyFlags);extern File my_open(const char *FileName,int Flags,myf MyFlags);extern File my_register_filename(File fd, const char *FileName,				 enum file_type type_of_file,				 uint error_message_number, myf MyFlags);extern File my_create(const char *FileName,int CreateFlags,		      int AccsesFlags, myf MyFlags);extern int my_close(File Filedes,myf MyFlags);extern File my_dup(File file, myf MyFlags);extern int my_mkdir(const char *dir, int Flags, myf MyFlags);extern int my_readlink(char *to, const char *filename, myf MyFlags);extern int my_realpath(char *to, const char *filename, myf MyFlags);extern File my_create_with_symlink(const char *linkname, const char *filename,				   int createflags, int access_flags,				   myf MyFlags);