/**********************************************************************
 * $Id: avc.h 8c2da2c75918f3f65f0046acaebdbc929e6c162b 2018-06-24 14:47:47 +0200 Even Rouault $
 *
 * Name:     avc.h
 * Project:  Arc/Info Vector coverage (AVC) BIN<->E00 conversion library
 * Language: ANSI C
 * Purpose:  Header file containing all definitions for the library.
 * Author:   Daniel Morissette, dmorissette@dmsolutions.ca
 *
 **********************************************************************
 * Copyright (c) 1999-2001, Daniel Morissette
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
 * and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included
 * in all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 * DEALINGS IN THE SOFTWARE.
 **********************************************************************
 *
 * $Log: avc.h,v $
 * Revision 1.25  2008/07/23 20:51:38  dmorissette
 * Fixed GCC 4.1.x compile warnings related to use of char vs unsigned char
 * (GDAL/OGR ticket http://trac.osgeo.org/gdal/ticket/2495)
 *
 * Revision 1.24  2006/08/17 20:09:45  dmorissette
 * Update for 2.0.0 release
 *
 * Revision 1.23  2006/08/17 18:56:42  dmorissette
 * Support for reading standalone info tables (just tables, no coverage
 * data) by pointing AVCE00ReadOpen() to the info directory (bug 1549).
 *
 * Revision 1.22  2006/06/27 18:38:43  dmorissette
 * Cleaned up E00 reading (bug 1497, patch from James F.)
 *
 * Revision 1.21  2006/06/16 11:48:11  daniel
 * New functions to read E00 files directly as opposed to translating to
 * binary coverage. Used in the implementation of E00 read support in OGR.
 * Contributed by James E. Flemer. (bug 1497)
 *
 * Revision 1.20  2006/06/14 16:31:28  daniel
 * Added support for AVCCoverPC2 type (bug 1491)
 *
 * Revision 1.19  2005/06/03 03:49:58  daniel
 * Update email address, website url, and copyright dates
 *
 * Revision 1.18  2005/06/03 03:29:16  daniel
 * Ready for 1.3.0 release
 *
 * Revision 1.17  2004/02/11 05:49:44  daniel
 * Added support for deleted flag in arc.dir (bug 2332)
 *
 * Revision 1.16  2002/02/14 16:34:15  warmerda
 * fixed prototype name for AVCBinReadNextPrj
 *
 * Revision 1.15  2002/02/13 20:35:24  warmerda
 * added AVCBinReadObject
 *
 * Revision 1.14  2001/11/25 21:15:23  daniel
 * Added hack (AVC_MAP_TYPE40_TO_DOUBLE) to map type 40 fields bigger than 8
 * digits to double precision as we generate E00 output (bug599)
 *
 * Revision 1.13  2001/02/20 15:24:11  daniel
 * Updated AVC_VERSION="1.2.0 (2000-10-17)"
 *
 * Revision 1.12  2000/09/26 21:38:44  daniel
 * Updated AVC_VERSION
 *
 * Revision 1.11  2000/09/26 20:21:04  daniel
 * Added AVCCoverPC write
 *
 * Revision 1.10  2000/09/22 19:45:20  daniel
 * Switch to MIT-style license
 *
 * Revision 1.9  2000/05/29 15:31:30  daniel
 * Added Japanese DBCS support
 *
 * Revision 1.8  2000/01/10 02:56:01  daniel
 * Added read support for "weird" coverages
 *
 * Revision 1.7  1999/12/24 07:18:34  daniel
 * Added PC Arc/Info coverages support
 *
 * Revision 1.6  1999/08/23 18:15:56  daniel
 * Added AVCE00DeleteCoverage()
 *
 * Revision 1.5  1999/06/08 22:07:28  daniel
 * Added AVCReadWrite in AVCAccess type
 *
 * Revision 1.4  1999/05/17 16:16:41  daniel
 * Added RXP + TXT/TX6/TX7 write support
 *
 * Revision 1.3  1999/05/11 02:15:04  daniel
 * Added coverage write support
 *
 * Revision 1.2  1999/02/25 03:39:39  daniel
 * Added TXT, TX6/TX7, RXP and RPL support
 *
 * Revision 1.1  1999/01/29 16:29:24  daniel
 * Initial revision
 *
 **********************************************************************/

#ifndef AVC_H_INCLUDED_
#define AVC_H_INCLUDED_

#include "cpl_conv.h"
#include "cpl_string.h"

#ifdef GDAL_COMPILATION
#ifdef RENAME_INTERNAL_SHAPELIB_SYMBOLS
#include "gdal_shapelib_symbol_rename.h"
#endif
#include "shapefil.h"
#else
#include "dbfopen.h"
#endif

#include "avc_mbyte.h"

CPL_C_START

/*---------------------------------------------------------------------
 * Current version of the AVCE00 library... always useful!
 *--------------------------------------------------------------------*/
#define AVC_VERSION "2.0.0 (2006-08-17)"

/* Coverage precision
 */
#define AVC_DEFAULT_PREC   0
#define AVC_SINGLE_PREC    1
#define AVC_DOUBLE_PREC    2

/* AVC_FORMAT_DBF_FLOAT used as nPrecision value only for AVCPrintRealValue()
 */
#define AVC_FORMAT_DBF_FLOAT  42

/* Coverage file types
 */
typedef enum
{
    AVCFileUnknown = 0,
    AVCFileARC,
    AVCFilePAL,
    AVCFileCNT,
    AVCFileLAB,
    AVCFilePRJ,
    AVCFileTOL,
    AVCFileLOG,
    AVCFileTXT,  /* TXT and TX6 share the same binary format */
    AVCFileTX6,
    AVCFileRXP,
    AVCFileRPL,  /* RPL is a PAL for a region */
    AVCFileTABLE
}AVCFileType;

/* Read or Write access flag
 */
typedef enum
{
    AVCRead,
    AVCWrite,
    AVCReadWrite
} AVCAccess;

/* Coverage type: PC Arc/Info or Unix Arc/Info v7
 */
typedef enum
{
    AVCCoverTypeUnknown = 0,
    AVCCoverV7,
    AVCCoverPC,
    AVCCoverPC2,   /* Unknown version... hybrid between V7 and PC !!! */
    AVCCoverWeird, /* Unknown version... hybrid between V7 and PC !!! */
    AVCCoverV7Tables /* Standalone tables, only an info directory     */
} AVCCoverType;

/* Enum for byte ordering
 */
typedef enum
{
    AVCBigEndian,    /* CPL_MSB, Motorola ordering */
    AVCLittleEndian  /* CPL_LSB, Intel ordering */
} AVCByteOrder;

/* Macros to establish byte ordering for each coverage type
 * The rule until now: all coverage types use big endian (Motorola ordering)
 * except PC Arc/Info coverages variant 1 (AVCCoverPC).
 */
#define AVC_COVER_BYTE_ORDER(cover_type)  \
   (((cover_type) == AVCCoverPC ) ? AVCLittleEndian : AVCBigEndian )

/*=====================================================================
                        Structures
 =====================================================================*/

/*---------------------------------------------------------------------
 * Structures defining various Arc/Info objects types.
 * These are shared by the Binary and the E00 functions.
 *--------------------------------------------------------------------*/

typedef struct AVCVertex_t
{
    double      x;      /* Even for single precision, we always         */
    double      y;      /* use doubles for the vertices in memory.      */
}AVCVertex;

/*---------------------------------------------------------------------
 * AVCArc: Information about an ARC
 *--------------------------------------------------------------------*/
typedef struct AVCArc_t
{
    GInt32      nArcId;
    GInt32      nUserId;
    GInt32      nFNode;
    GInt32      nTNode;
    GInt32      nLPoly;
    GInt32      nRPoly;
    GInt32      numVertices;
    AVCVertex   *pasVertices;
}AVCArc;

/*---------------------------------------------------------------------
 * AVCPal: A PAL (Polygon Arc List) references all the arcs that
 *         constitute a polygon.
 *--------------------------------------------------------------------*/
typedef struct AVCPalArc_t
{
    GInt32      nArcId;
    GInt32      nFNode;
    GInt32      nAdjPoly;
}AVCPalArc;

typedef struct AVCPal_t
{
    GInt32      nPolyId;
    AVCVertex   sMin;
    AVCVertex   sMax;
    GInt32      numArcs;
    AVCPalArc   *pasArcs;
}AVCPal;

/*---------------------------------------------------------------------
 * AVCCnt: Information about a CNT (polygon centroid)
 *--------------------------------------------------------------------*/
typedef struct AVCCnt_t
{
    GInt32      nPolyId;
    AVCVertex   sCoord;
    GInt32      numLabels;      /* 0 or 1 */
    GInt32      *panLabelIds;
}AVCCnt;

/*---------------------------------------------------------------------
 * AVCLab: Information about a LAB (polygon Label)
 *--------------------------------------------------------------------*/
typedef struct AVCLab_t
{
    GInt32      nValue;
    GInt32      nPolyId;
    AVCVertex   sCoord1;
    AVCVertex   sCoord2;
    AVCVertex   sCoord3;
}AVCLab;

/*---------------------------------------------------------------------
 * AVCTol: Information about a TOL record (coverage tolerances)
 *--------------------------------------------------------------------*/
typedef struct AVCTol_t
{
    GInt32      nIndex;
    GInt32      nFlag;
    double      dValue;
}AVCTol;

/*---------------------------------------------------------------------
 * AVCTxt: Information about a TXT/TX6/TX7 record (annotations)
 *--------------------------------------------------------------------*/
typedef struct AVCTxt_t
{
    GInt32      nTxtId;
    GInt32      nUserId;
    GInt32      nLevel;
    float       f_1e2;  /* Always (float)-1e+20, even for double precision! */
    GInt32      nSymbol;
    GInt32      numVerticesLine;
    GInt32      n28;    /* Unknown value at byte 28 */
    GInt32      numChars;
    GInt32      numVerticesArrow;

    GInt16      anJust1[20];
    GInt16      anJust2[20];

    double      dHeight;
    double      dV2;    /* ??? */
    double      dV3;    /* ??? */

    GByte       *pszText; /* Needs to be unsigned char for DBCS */

    AVCVertex   *pasVertices;
}AVCTxt;

/*---------------------------------------------------------------------
 * AVCRxp: Information about a RXP record (something related to regions...)
 *--------------------------------------------------------------------*/
typedef struct AVCRxp_t
{
    GInt32      n1;
    GInt32      n2;
}AVCRxp;

/*---------------------------------------------------------------------
 * AVCTableDef: Definition of an INFO table's structure.
 *               This info is read from several files:
 *                   info/arc.dir
 *                   info/arc####.dat
 *                   info/arc####.nit
 *
 *               And the data for the table itself is stored in a binary
 *               file in the coverage directory.
 *--------------------------------------------------------------------*/

typedef struct AVCFieldInfo_t
{
    char        szName[17];
    GInt16      nSize;
    GInt16      v2;
    GInt16      nOffset;
    GInt16      v4;
    GInt16      v5;
    GInt16      nFmtWidth;
    GInt16      nFmtPrec;
    GInt16      nType1;
    GInt16      nType2;
    GInt16      v10;
    GInt16      v11;
    GInt16      v12;
    GInt16      v13;
    char        szAltName[17];
    GInt16      nIndex;         /* >0 if valid, or -1 if field is deleted */
}AVCFieldInfo;

#define AVC_FT_DATE     10
#define AVC_FT_CHAR     20
#define AVC_FT_FIXINT   30
#define AVC_FT_FIXNUM   40
#define AVC_FT_BININT   50
#define AVC_FT_BINFLOAT 60

typedef struct AVCTableDef_t
{
    /* Stuff read from the arc.dir file
     * (1 record, corresponding to this table, from the arc.dir file)
     */
    char        szTableName[33];
    char        szInfoFile[9];
    GInt16      numFields;
    GInt16      nRecSize;
    GInt32      numRecords;
    char        szExternal[3];  /* "XX" or "  " */
    GInt16      bDeletedFlag;   /* 1 if deleted, 0 if table is active */

    /* Data file path read from the arc####.dat file
     */
    char        szDataFile[81];

    /* Field information read from the arc####.nit file
     */
    AVCFieldInfo *pasFieldDef;
} AVCTableDef;

typedef struct AVCField_t
{
    GInt16      nInt16;
    GInt32      nInt32;
    float       fFloat;
    double      dDouble;
    GByte       *pszStr;
} AVCField;

/*---------------------------------------------------------------------
 * Stuff related to buffered reading of raw binary files
 *--------------------------------------------------------------------*/

#define AVCRAWBIN_READBUFSIZE 1024

typedef struct AVCRawBinFile_t
{
    VSILFILE    *fp;
    char        *pszFname;
    AVCAccess   eAccess;
    AVCByteOrder eByteOrder;
    GByte       abyBuf[AVCRAWBIN_READBUFSIZE];
    int         nOffset;        /* Location of current buffer in the file */
    int         nCurSize;       /* Nbr of bytes currently loaded        */
    int         nCurPos;        /* Next byte to read from abyBuf[]      */

    int         nFileDataSize;  /* File Size as stated in the header */
                                /* EOF=TRUE passed this point in file */
                                /* Set to -1 if not specified. */

    /* Handle on dataset's multibyte character encoding info. */
    AVCDBCSInfo *psDBCSInfo;

} AVCRawBinFile;

/*---------------------------------------------------------------------
 * Stuff related to reading and writing binary coverage files
 *--------------------------------------------------------------------*/

typedef struct AVCBinHeader_t
{
    GUInt32     nSignature;
    GInt32      nPrecision;     /* <0 for double prec., >0 for single prec. */
    GInt32      nRecordSize;    /* nbr of 2 byte words, 0 for var. length   */
    GInt32      nLength;        /* Overall file length, in 2 byte words     */
}AVCBinHeader;

typedef struct AVCBinFile_t
{
    AVCRawBinFile *psRawBinFile;
    char          *pszFilename;
    AVCRawBinFile *psIndexFile;   /* Index file, Write mode only */

    DBFHandle     hDBFFile;       /* Used for AVCCoverPC/PC2 DBF TABLES only */
    int           nCurDBFRecord;  /* 0-based record index in DBF file */

    AVCCoverType  eCoverType;
    AVCFileType   eFileType;
    int           nPrecision;     /* AVC_SINGLE/DOUBLE_PREC  */

    union
    {
        AVCTableDef  *psTableDef;
    }hdr;

    /* cur.* : temp. storage used to read one record (ARC, PAL, ... or
     *         Table record) from the file.
     */
    union
    {
        AVCArc       *psArc;
        AVCPal       *psPal;
        AVCCnt       *psCnt;
        AVCLab       *psLab;
        AVCTol       *psTol;
        AVCTxt       *psTxt;
        AVCRxp       *psRxp;
        AVCField     *pasFields;
        char         **papszPrj;
    }cur;

} AVCBinFile;

/*---------------------------------------------------------------------
 * Stuff related to the generation of E00
 *--------------------------------------------------------------------*/

/*---------------------------------------------------------------------
 *                        AVCE00GenInfo structure
 * This structure is used by the E00 generator functions to store
 * their buffer and their current state in case they need to be
 * called more than once for a given object type (i.e. ARC, PAL and IFO).
 *--------------------------------------------------------------------*/

typedef struct AVCE00GenInfo_t
{
    char        *pszBuf;
    int         nBufSize;

    int         nPrecision;     /* AVC_SINGLE/DOUBLE_PREC       */
    int         iCurItem;
    int         numItems;
}AVCE00GenInfo;

/*---------------------------------------------------------------------
 * Stuff related to the parsing of E00
 *--------------------------------------------------------------------*/

/*---------------------------------------------------------------------
 *                        AVCE00ParseInfo structure
 * This structure is used by the E00 parser functions to store
 * their buffer and their current state while parsing an object.
 *--------------------------------------------------------------------*/

struct AVCE00ParseInfo
{
    AVCFileType eFileType = AVCFileUnknown;
    int         nPrecision = 0;     /* AVC_SINGLE/DOUBLE_PREC       */
    int         iCurItem = 0;
    int         numItems = 0;
    int         nStartLineNum = 0;
    int         nCurLineNum = 0;

    int         nCurObjectId = 0;
    GBool       bForceEndOfSection = 0;  /* For sections that don't have an */
                                     /* explicit end-of-section line.   */
    AVCFileType eSuperSectionType = AVCFileUnknown;/* For sections containing several files*/
    char        *pszSectionHdrLine = nullptr;  /* Used by supersection types      */

    struct
    {
        AVCTableDef  *psTableDef = nullptr;
    } hdr;
    GBool       bTableHdrComplete = 0;   /* FALSE until table header is */
                                     /* finished parsing */
    int         nTableE00RecLength = 0;

    /* cur.* : temp. storage used to store current object (ARC, PAL, ... or
     *         Table record) from the file.
     */
    union
    {
        AVCArc       *psArc;
        AVCPal       *psPal;
        AVCCnt       *psCnt;
        AVCLab       *psLab;
        AVCTol       *psTol;
        AVCTxt       *psTxt;
        AVCRxp       *psRxp;
        AVCField     *pasFields;
    }cur;
    CPLStringList aosPrj;

    char        *pszBuf = nullptr;        /* Buffer used only for TABLEs  */
    int         nBufSize = 0;

    AVCE00ParseInfo() { cur.psArc = nullptr; }
};

/*---------------------------------------------------------------------
 * Stuff related to the transparent binary -> E00 conversion
 *--------------------------------------------------------------------*/
typedef struct AVCE00Section_t
{
    AVCFileType eType;        /* File Type                      */
    char        *pszName;     /* E00 section or Table Name      */
    char        *pszFilename; /* Binary/E00 file filename       */
    int         nLineNum;     /* E00 line number                */
    int         nFeatureCount;
}AVCE00Section;

typedef struct AVCE00ReadInfo_t
{
    char        *pszCoverPath;
    char        *pszInfoPath;
    char        *pszCoverName;
    AVCCoverType eCoverType;

    /* pasSections is built when the coverage is opened and describes
     * the skeleton of the E00 file.
     */
    AVCE00Section *pasSections;
    int            numSections;

    /* If bReadAllSections=TRUE then reading automatically continues to
     * the next section when a section finishes. (This is the default)
     * Otherwise, you can use AVCE00ReadGotoSection() to read one section
     * at a time... this will set bReadAllSections=FALSE.
     */
    GBool         bReadAllSections;

    /* Info about the file (or E00 section) currently being processed
     */
    int           iCurSection;
    AVCBinFile    *hFile;

    int           iCurStep;  /* AVC_GEN_* values, see below */
    AVCE00GenInfo *hGenInfo;

    /* Info related to multibyte character encoding
     */
    AVCDBCSInfo *psDBCSInfo;

} *AVCE00ReadPtr;

typedef struct AVCE00ReadInfoE00_t
{
    char        *pszCoverPath;
    char        *pszCoverName;

    AVCE00ParseInfo *hParseInfo;
    AVCFileType  eCurFileType;

    /* pasSections is built when the coverage is opened and describes
     * the sections in the E00 file.
     */
    AVCE00Section *pasSections;
    int            numSections;

    /* If bReadAllSections=TRUE then reading automatically continues to
     * the next section when a section finishes. (This is the default)
     * Otherwise, you can use AVCE00ReadGotoSectionE00() to read one
     * section at a time.
     */
    GBool         bReadAllSections;

    /* File handle of the E00 file currently being processed
     */
    VSILFILE     *hFile;

} *AVCE00ReadE00Ptr;

/* E00 generation steps... tells the AVCE00Read*() functions which
 * parts of the given E00 file are currently being processed.
 */
#define AVC_GEN_NOTSTARTED      0
#define AVC_GEN_DATA            1
#define AVC_GEN_ENDSECTION      2
#define AVC_GEN_TABLEHEADER     3
#define AVC_GEN_TABLEDATA       4

/*---------------------------------------------------------------------
 * Stuff related to the transparent E00 -> binary conversion
 *--------------------------------------------------------------------*/
typedef struct AVCE00WriteInfo_t
{
    char        *pszCoverPath;
    char        *pszInfoPath;
    char        *pszCoverName;
    AVCCoverType eCoverType;

    /* Info about the file (or E00 section) currently being processed
     */
    AVCFileType  eCurFileType;
    AVCBinFile  *hFile;

    /* Requested precision for the new coverage... may differ from the
     * precision of the E00 input lines.  (AVC_SINGLE_PREC or AVC_DOUBLE_PREC)
     */
    int          nPrecision;

    AVCE00ParseInfo *hParseInfo;

    /* Info related to multibyte character encoding
     */
    AVCDBCSInfo *psDBCSInfo;

} *AVCE00WritePtr;

/* Coverage generation steps... used to store the current state of the
 * AVCE00WriteNextLine() function.
 */
#define AVC_WR_TOPLEVEL         0
#define AVC_WR_READING_SECTION

/*=====================================================================
              Function prototypes (lower-level lib. functions)
 =====================================================================*/

/*---------------------------------------------------------------------
 * Functions related to buffered reading of raw binary files (and writing)
 *--------------------------------------------------------------------*/
AVCRawBinFile *AVCRawBinOpen(const char *pszFname, const char *pszAccess,
                             AVCByteOrder eFileByteOrder,
                             AVCDBCSInfo *psDBCSInfo);
void        AVCRawBinClose(AVCRawBinFile *psInfo);
void        AVCRawBinFSeek(AVCRawBinFile *psInfo, int nOffset, int nFrom);
GBool       AVCRawBinEOF(AVCRawBinFile *psInfo);
void        AVCRawBinSetFileDataSize(AVCRawBinFile *psInfo, int nDataSize);
int AVCRawBinIsFileGreaterThan(AVCRawBinFile *psFile, vsi_l_offset nSize);

void        AVCRawBinReadBytes(AVCRawBinFile *psInfo, int nBytesToRead,
                               GByte *pBuf);
GInt16      AVCRawBinReadInt16(AVCRawBinFile *psInfo);
GInt32      AVCRawBinReadInt32(AVCRawBinFile *psInfo);
float       AVCRawBinReadFloat(AVCRawBinFile *psInfo);
double      AVCRawBinReadDouble(AVCRawBinFile *psInfo);
void        AVCRawBinReadString(AVCRawBinFile *psFile, int nBytesToRead,
                                GByte *pBuf);

void        AVCRawBinWriteBytes(AVCRawBinFile *psFile, int nBytesToWrite,
                                const GByte *pBuf);
void        AVCRawBinWriteInt16(AVCRawBinFile *psFile, GInt16 n16Value);
void        AVCRawBinWriteInt32(AVCRawBinFile *psFile, GInt32 n32Value);
void        AVCRawBinWriteFloat(AVCRawBinFile *psFile, float fValue);
void        AVCRawBinWriteDouble(AVCRawBinFile *psFile, double dValue);
void        AVCRawBinWriteZeros(AVCRawBinFile *psFile, int nBytesToWrite);
void        AVCRawBinWritePaddedString(AVCRawBinFile *psFile, int nFieldSize,
                                       const GByte *pszString);

/*---------------------------------------------------------------------
 * Functions related to reading the binary coverage files
 *--------------------------------------------------------------------*/

AVCBinFile *AVCBinReadOpen(const char *pszPath, const char *pszName,
                           AVCCoverType eCoverType, AVCFileType eType,
                           AVCDBCSInfo *psDBCSInfo);
void        AVCBinReadClose(AVCBinFile *psFile);

int         AVCBinReadRewind(AVCBinFile *psFile);

void       *AVCBinReadObject(AVCBinFile *psFile, int iObjIndex );
void       *AVCBinReadNextObject(AVCBinFile *psFile);
AVCArc     *AVCBinReadNextArc(AVCBinFile *psFile);
AVCPal     *AVCBinReadNextPal(AVCBinFile *psFile);
AVCCnt     *AVCBinReadNextCnt(AVCBinFile *psFile);
AVCLab     *AVCBinReadNextLab(AVCBinFile *psFile);
AVCTol     *AVCBinReadNextTol(AVCBinFile *psFile);
AVCTxt     *AVCBinReadNextTxt(AVCBinFile *psFile);
AVCRxp     *AVCBinReadNextRxp(AVCBinFile *psFile);
AVCField   *AVCBinReadNextTableRec(AVCBinFile *psFile);
char      **AVCBinReadNextPrj(AVCBinFile *psFile);

char      **AVCBinReadListTables(const char *pszInfoPath,
                                 const char *pszCoverName,
                                 char ***ppapszArcDatFiles,
                                 AVCCoverType eCoverType,
                                 AVCDBCSInfo *psDBCSInfo);

/*---------------------------------------------------------------------
 * Functions related to writing the binary coverage files
 *--------------------------------------------------------------------*/
AVCBinFile *AVCBinWriteCreate(const char *pszPath, const char *pszName,
                              AVCCoverType eCoverType,
                              AVCFileType eType, int nPrecision,
                              AVCDBCSInfo *psDBCSInfo);
AVCBinFile *AVCBinWriteCreateTable(const char *pszInfoPath,
                                   const char *pszCoverName,
                                   AVCTableDef *psSrcTableDef,
                                   AVCCoverType eCoverType,
                                   int nPrecision, AVCDBCSInfo *psDBCSInfo);
void        AVCBinWriteClose(AVCBinFile *psFile);

int         AVCBinWriteHeader(AVCBinFile *psFile);
int         AVCBinWriteObject(AVCBinFile *psFile, void *psObj);
int         AVCBinWriteArc(AVCBinFile *psFile, AVCArc *psArc);
int         AVCBinWritePal(AVCBinFile *psFile, AVCPal *psPal);
int         AVCBinWriteCnt(AVCBinFile *psFile, AVCCnt *psCnt);
int         AVCBinWriteLab(AVCBinFile *psFile, AVCLab *psLab);
int         AVCBinWriteTol(AVCBinFile *psFile, AVCTol *psTol);
int         AVCBinWritePrj(AVCBinFile *psFile, char **papszPrj);
int         AVCBinWriteTxt(AVCBinFile *psFile, AVCTxt *psTxt);
int         AVCBinWriteRxp(AVCBinFile *psFile, AVCRxp *psRxp);
int         AVCBinWriteTableRec(AVCBinFile *psFile, AVCField *pasFields);

/*---------------------------------------------------------------------
 * Functions related to the generation of E00
 *--------------------------------------------------------------------*/
AVCE00GenInfo  *AVCE00GenInfoAlloc(int nCoverPrecision);
void        AVCE00GenInfoFree(AVCE00GenInfo *psInfo);
void        AVCE00GenReset(AVCE00GenInfo  *psInfo);

const char *AVCE00GenStartSection(AVCE00GenInfo *psInfo, AVCFileType eType,
                                  const char *pszFilename);
const char *AVCE00GenEndSection(AVCE00GenInfo *psInfo, AVCFileType eType,
                                GBool bCont);

const char *AVCE00GenObject(AVCE00GenInfo *psInfo,
                            AVCFileType eType, void *psObj, GBool bCont);
const char *AVCE00GenArc(AVCE00GenInfo *psInfo, AVCArc *psArc, GBool bCont);
const char *AVCE00GenPal(AVCE00GenInfo *psInfo, AVCPal *psPal, GBool bCont);
const char *AVCE00GenCnt(AVCE00GenInfo *psInfo, AVCCnt *psCnt, GBool bCont);
const char *AVCE00GenLab(AVCE00GenInfo *psInfo, AVCLab *psLab, GBool bCont);
const char *AVCE00GenTol(AVCE00GenInfo *psInfo, AVCTol *psTol, GBool bCont);
const char *AVCE00GenTxt(AVCE00GenInfo *psInfo, AVCTxt *psTxt, GBool bCont);
const char *AVCE00GenTx6(AVCE00GenInfo *psInfo, AVCTxt *psTxt, GBool bCont);
const char *AVCE00GenPrj(AVCE00GenInfo *psInfo, char **papszPrj, GBool bCont);
const char *AVCE00GenRxp(AVCE00GenInfo *psInfo, AVCRxp *psRxp, GBool bCont);

const char *AVCE00GenTableHdr(AVCE00GenInfo *psInfo, AVCTableDef *psDef,
                              GBool bCont);
const char *AVCE00GenTableRec(AVCE00GenInfo *psInfo, int numFields,
                              AVCFieldInfo *pasDef, AVCField *pasFields,
                              GBool bCont);

/*---------------------------------------------------------------------
 * Functions related to parsing E00 lines
 *--------------------------------------------------------------------*/
AVCE00ParseInfo  *AVCE00ParseInfoAlloc(void);
void    AVCE00ParseInfoFree(AVCE00ParseInfo *psInfo);
void    AVCE00ParseReset(AVCE00ParseInfo  *psInfo);

AVCFileType AVCE00ParseSectionHeader(AVCE00ParseInfo  *psInfo,
                                     const char *pszLine);
GBool   AVCE00ParseSectionEnd(AVCE00ParseInfo  *psInfo, const char *pszLine,
                              GBool bResetParseInfo);
AVCFileType AVCE00ParseSuperSectionHeader(AVCE00ParseInfo  *psInfo,
                                          const char *pszLine);
GBool   AVCE00ParseSuperSectionEnd(AVCE00ParseInfo  *psInfo,
                                   const char *pszLine );

void    *AVCE00ParseNextLine(AVCE00ParseInfo  *psInfo, const char *pszLine);
AVCArc  *AVCE00ParseNextArcLine(AVCE00ParseInfo *psInfo, const char *pszLine);
AVCPal  *AVCE00ParseNextPalLine(AVCE00ParseInfo *psInfo, const char *pszLine);
AVCCnt  *AVCE00ParseNextCntLine(AVCE00ParseInfo *psInfo, const char *pszLine);
AVCLab  *AVCE00ParseNextLabLine(AVCE00ParseInfo *psInfo, const char *pszLine);
AVCTol  *AVCE00ParseNextTolLine(AVCE00ParseInfo *psInfo, const char *pszLine);
AVCTxt  *AVCE00ParseNextTxtLine(AVCE00ParseInfo *psInfo, const char *pszLine);
AVCTxt  *AVCE00ParseNextTx6Line(AVCE00ParseInfo *psInfo, const char *pszLine);
char   **AVCE00ParseNextPrjLine(AVCE00ParseInfo *psInfo, const char *pszLine);
AVCRxp  *AVCE00ParseNextRxpLine(AVCE00ParseInfo *psInfo, const char *pszLine);
AVCTableDef *AVCE00ParseNextTableDefLine(AVCE00ParseInfo *psInfo,
                                         const char *pszLine);
AVCField    *AVCE00ParseNextTableRecLine(AVCE00ParseInfo *psInfo,
                                         const char *pszLine);

/*---------------------------------------------------------------------
 * Misc. functions shared by several parts of the lib.
 *--------------------------------------------------------------------*/
int _AVCE00ComputeRecSize(int numFields, AVCFieldInfo *pasDef,
                          GBool bMapType40ToDouble);

void _AVCDestroyTableFields(AVCTableDef *psTableDef, AVCField *pasFields);
void _AVCDestroyTableDef(AVCTableDef *psTableDef);
AVCTableDef *_AVCDupTableDef(AVCTableDef *psSrcDef);

GBool AVCFileExists(const char *pszPath, const char *pszName);
char *AVCAdjustCaseSensitiveFilename(char *pszFname);
int  AVCPrintRealValue(char *pszBuf, size_t nBufLen, int nPrecision, AVCFileType eType,
                       double dValue);

/*=====================================================================
              Function prototypes (THE PUBLIC ONES)
 =====================================================================*/

/*---------------------------------------------------------------------
 * Functions to read E00
 *--------------------------------------------------------------------*/
AVCE00ReadE00Ptr AVCE00ReadOpenE00(const char *pszE00FileName);
void             AVCE00ReadCloseE00(AVCE00ReadE00Ptr psRead);
int              AVCE00ReadRewindE00(AVCE00ReadE00Ptr psRead);
void            *AVCE00ReadNextObjectE00(AVCE00ReadE00Ptr psRead);

AVCE00Section  *AVCE00ReadSectionsListE00(AVCE00ReadE00Ptr psRead, int *numSect);
int             AVCE00ReadGotoSectionE00(AVCE00ReadE00Ptr psRead,
                                         AVCE00Section *psSect,
                                         GBool bContinue);

/*---------------------------------------------------------------------
 * Functions to make a binary coverage appear as E00
 *--------------------------------------------------------------------*/

AVCE00ReadPtr   AVCE00ReadOpen(const char *pszCoverPath);
void            AVCE00ReadClose(AVCE00ReadPtr psInfo);
const char     *AVCE00ReadNextLine(AVCE00ReadPtr psInfo);
int             AVCE00ReadRewind(AVCE00ReadPtr psInfo);

AVCE00Section  *AVCE00ReadSectionsList(AVCE00ReadPtr psInfo, int *numSect);
int             AVCE00ReadGotoSection(AVCE00ReadPtr psInfo,
                                      AVCE00Section *psSect,
                                      GBool bContinue);

/*---------------------------------------------------------------------
 * Functions to write E00 lines to a binary coverage
 *--------------------------------------------------------------------*/

AVCE00WritePtr  AVCE00WriteOpen(const char *pszCoverPath,
                                AVCCoverType eNewCoverType, int nPrecision);
void            AVCE00WriteClose(AVCE00WritePtr psInfo);
int             AVCE00WriteNextLine(AVCE00WritePtr psInfo,
                                    const char *pszLine);
int             AVCE00DeleteCoverage(const char *pszCoverPath);

CPL_C_END

#endif /* AVC_H_INCLUDED_ */
