SHPRestoreSHX()

int SHPAPI_CALL SHPRestoreSHX	(	const char *	pszLayer,
		const char *	pszAccess,
		SAHooks *	psHooks
	)

Definition at line 696 of file shpopen.c.

{
    char            *pszFullname;
    SAFile          fpSHP, fpSHX;
 
 
    uchar           *pabyBuf;
    int             nLenWithoutExtension;
    unsigned int    nSHPFilesize;
 
    unsigned int    nCurrentSHPOffset = 100;
    size_t          nRealSHXContentSize = 100;
 
    const char      pszSHXAccess[] = "w+b";
    char            *pabySHXHeader;
    char            abyReadedRecord[8];
    unsigned int    niRecord = 0;
    unsigned int    nRecordLength = 0;
    unsigned int    nRecordOffset = 50;
 
/* -------------------------------------------------------------------- */
/*      Ensure the access string is one of the legal ones.  We          */
/*      ensure the result string indicates binary to avoid common       */
/*      problems on Windows.                                            */
/* -------------------------------------------------------------------- */
    if( strcmp(pszAccess,"rb+") == 0 || strcmp(pszAccess,"r+b") == 0
        || strcmp(pszAccess,"r+") == 0 )
        pszAccess = "r+b";
    else
    {
        pszAccess = "rb";
    }
 
/* -------------------------------------------------------------------- */
/*  Establish the byte order on this machine.                           */
/* -------------------------------------------------------------------- */
#if !defined(bBigEndian)
    {
        int i = 1;
        if( *((uchar *) &i) == 1 )
            bBigEndian = FALSE;
        else
            bBigEndian = TRUE;
    }
#endif
 
/* -------------------------------------------------------------------- */
/*  Open the .shp file.  Note that files pulled from                    */
/*  a PC to Unix with upper case filenames won't work!                  */
/* -------------------------------------------------------------------- */
    nLenWithoutExtension = SHPGetLenWithoutExtension(pszLayer);
    pszFullname = STATIC_CAST(char *, malloc(nLenWithoutExtension + 5));
    memcpy(pszFullname, pszLayer, nLenWithoutExtension);
    memcpy(pszFullname + nLenWithoutExtension, ".shp", 5);
    fpSHP = psHooks->FOpen(pszFullname, pszAccess );
    if( fpSHP == SHPLIB_NULLPTR )
    {
        memcpy(pszFullname + nLenWithoutExtension, ".SHP", 5);
        fpSHP = psHooks->FOpen(pszFullname, pszAccess );
    }
 
    if( fpSHP == SHPLIB_NULLPTR )
    {
        size_t nMessageLen = strlen( pszFullname ) * 2 + 256;
        char* pszMessage = STATIC_CAST(char *, malloc( nMessageLen ));
 
        pszFullname[nLenWithoutExtension] = 0;
        snprintf( pszMessage, nMessageLen, "Unable to open %s.shp or %s.SHP.",
                  pszFullname, pszFullname );
        psHooks->Error( pszMessage );
        free( pszMessage );
 
        free( pszFullname );
 
        return( 0 );
    }
 
/* -------------------------------------------------------------------- */
/*  Read the file size from the SHP file.                               */
/* -------------------------------------------------------------------- */
    pabyBuf = STATIC_CAST(uchar *, malloc(100));
    if( psHooks->FRead( pabyBuf, 100, 1, fpSHP ) != 1 )
    {
        psHooks->Error( ".shp file is unreadable, or corrupt." );
        psHooks->FClose( fpSHP );
 
        free( pabyBuf );
        free( pszFullname );
 
        return( 0 );
    }
 
    nSHPFilesize = (STATIC_CAST(unsigned int, pabyBuf[24])<<24)|(pabyBuf[25]<<16)|
                   (pabyBuf[26]<<8)|pabyBuf[27];
    if( nSHPFilesize < UINT_MAX / 2 )
        nSHPFilesize *= 2;
    else
        nSHPFilesize = (UINT_MAX / 2) * 2;
 
    memcpy(pszFullname + nLenWithoutExtension, ".shx", 5);
    fpSHX = psHooks->FOpen( pszFullname, pszSHXAccess );
    if( fpSHX == SHPLIB_NULLPTR )
    {
        size_t nMessageLen = strlen( pszFullname ) * 2 + 256;
        char* pszMessage = STATIC_CAST(char *, malloc( nMessageLen ));
        pszFullname[nLenWithoutExtension] = 0;
        snprintf( pszMessage, nMessageLen,
                  "Error opening file %s.shx for writing", pszFullname );
        psHooks->Error( pszMessage );
        free( pszMessage );
 
        psHooks->FClose( fpSHP );
 
        free( pabyBuf );
        free( pszFullname );
 
        return( 0 );
    }
 
/* -------------------------------------------------------------------- */
/*  Open SHX and create it using SHP file content.                      */
/* -------------------------------------------------------------------- */
    psHooks->FSeek( fpSHP, 100, 0 );
    pabySHXHeader = STATIC_CAST(char *, malloc ( 100 ));
    memcpy( pabySHXHeader, pabyBuf, 100 );
    psHooks->FWrite( pabySHXHeader, 100, 1, fpSHX );
    free ( pabyBuf );
 
    while( nCurrentSHPOffset < nSHPFilesize )
    {
        if( psHooks->FRead( &niRecord, 4, 1, fpSHP ) == 1 &&
            psHooks->FRead( &nRecordLength, 4, 1, fpSHP ) == 1)
        {
            if( !bBigEndian ) SwapWord( 4, &nRecordOffset );
            memcpy( abyReadedRecord, &nRecordOffset, 4 );
            memcpy( abyReadedRecord + 4, &nRecordLength, 4 );
 
            psHooks->FWrite( abyReadedRecord, 8, 1, fpSHX );
 
            if ( !bBigEndian ) SwapWord( 4, &nRecordOffset );
            if ( !bBigEndian ) SwapWord( 4, &nRecordLength );
            nRecordOffset += nRecordLength + 4;
            nCurrentSHPOffset += 8 + nRecordLength * 2;
 
            psHooks->FSeek( fpSHP, nCurrentSHPOffset, 0 );
            nRealSHXContentSize += 8;
        }
        else
        {
            psHooks->Error( "Error parsing .shp to restore .shx"  );
 
            psHooks->FClose( fpSHX );
            psHooks->FClose( fpSHP );
 
            free( pabySHXHeader );
            free( pszFullname );
 
            return( 0 );
        }
    }
 
    nRealSHXContentSize /= 2; // Bytes counted -> WORDs
    if( !bBigEndian ) SwapWord( 4, &nRealSHXContentSize );
    psHooks->FSeek( fpSHX, 24, 0 );
    psHooks->FWrite( &nRealSHXContentSize, 4, 1, fpSHX );
 
    psHooks->FClose( fpSHP );
    psHooks->FClose( fpSHX );
 
    free ( pszFullname );
    free ( pabySHXHeader );
 
    return( 1 );
}

References bBigEndian, SAHooks::Error, FALSE, SAHooks::FClose, SAHooks::FOpen, SAHooks::FRead, free(), SAHooks::FSeek, SAHooks::FWrite, malloc(), SHPGetLenWithoutExtension(), SHPLIB_NULLPTR, STATIC_CAST, SwapWord(), and TRUE.

Referenced by SHPOpenLLEx().

Here is the call graph for this function:

Here is the caller graph for this function: