SHPOpenLL()

SHPHandle SHPAPI_CALL SHPOpenLL	(	const char *	pszShapeFile,
		const char *	pszAccess,
		SAHooks *	psHooks
	)

Definition at line 482 of file shpopen.c.

{
    char                *pszFullname, *pszBasename;
    SHPHandle           psSHP;
 
    uchar               *pabyBuf;
    int                 i;
    double              dValue;
 
/* -------------------------------------------------------------------- */
/*      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.                       */
/* -------------------------------------------------------------------- */
    i = 1;
    if( *((uchar *) &i) == 1 )
        bBigEndian = FALSE;
    else
        bBigEndian = TRUE;
 
/* -------------------------------------------------------------------- */
/*      Initialize the info structure.                                  */
/* -------------------------------------------------------------------- */
    psSHP = (SHPHandle) calloc(sizeof(SHPInfo),1);
 
    psSHP->bUpdated = FALSE;
    memcpy( &(psSHP->sHooks), psHooks, sizeof(SAHooks) );
 
/* -------------------------------------------------------------------- */
/*      Compute the base (layer) name.  If there is any extension       */
/*      on the passed in filename we will strip it off.                 */
/* -------------------------------------------------------------------- */
    pszBasename = (char *) malloc(strlen(pszLayer)+5);
    strcpy( pszBasename, pszLayer );
    for( i = strlen(pszBasename)-1;
         i > 0 && pszBasename[i] != '.' && pszBasename[i] != '/'
             && pszBasename[i] != '\\';
         i-- ) {}
 
    if( pszBasename[i] == '.' )
        pszBasename[i] = '\0';
 
/* -------------------------------------------------------------------- */
/*      Open the .shp and .shx files.  Note that files pulled from      */
/*      a PC to Unix with upper case filenames won't work!              */
/* -------------------------------------------------------------------- */
    pszFullname = (char *) malloc(strlen(pszBasename) + 5);
    sprintf( pszFullname, "%s.shp", pszBasename ) ;
    psSHP->fpSHP = psSHP->sHooks.FOpen(pszFullname, pszAccess );
    if( psSHP->fpSHP == NULL )
    {
        sprintf( pszFullname, "%s.SHP", pszBasename );
        psSHP->fpSHP = psSHP->sHooks.FOpen(pszFullname, pszAccess );
    }
 
    if( psSHP->fpSHP == NULL )
    {
        char *pszMessage = (char *) malloc(strlen(pszBasename)*2+256);
        sprintf( pszMessage, "Unable to open %s.shp or %s.SHP.",
                  pszBasename, pszBasename );
        psHooks->Error( pszMessage );
        free( pszMessage );
        free( psSHP );
        free( pszBasename );
        free( pszFullname );
        return( NULL );
    }
 
    sprintf( pszFullname, "%s.shx", pszBasename );
    psSHP->fpSHX =  psSHP->sHooks.FOpen(pszFullname, pszAccess );
    if( psSHP->fpSHX == NULL )
    {
        sprintf( pszFullname, "%s.SHX", pszBasename );
        psSHP->fpSHX = psSHP->sHooks.FOpen(pszFullname, pszAccess );
    }
 
    if( psSHP->fpSHX == NULL )
    {
        char *pszMessage = (char *) malloc(strlen(pszBasename)*2+256);
        sprintf( pszMessage, "Unable to open %s.shx or %s.SHX.",
                  pszBasename, pszBasename );
        psHooks->Error( pszMessage );
        free( pszMessage );
 
        psSHP->sHooks.FClose( psSHP->fpSHP );
        free( psSHP );
        free( pszBasename );
        free( pszFullname );
        return( NULL );
    }
 
    free( pszFullname );
    free( pszBasename );
 
/* -------------------------------------------------------------------- */
/*  Read the file size from the SHP file.                               */
/* -------------------------------------------------------------------- */
    pabyBuf = (uchar *) malloc(100);
    psSHP->sHooks.FRead( pabyBuf, 100, 1, psSHP->fpSHP );
 
    psSHP->nFileSize = ((unsigned int)pabyBuf[24] * 256 * 256 * 256
                        + (unsigned int)pabyBuf[25] * 256 * 256
                        + (unsigned int)pabyBuf[26] * 256
                        + (unsigned int)pabyBuf[27]) * 2;
 
/* -------------------------------------------------------------------- */
/*  Read SHX file Header info                                           */
/* -------------------------------------------------------------------- */
    if( psSHP->sHooks.FRead( pabyBuf, 100, 1, psSHP->fpSHX ) != 1
        || pabyBuf[0] != 0
        || pabyBuf[1] != 0
        || pabyBuf[2] != 0x27
        || (pabyBuf[3] != 0x0a && pabyBuf[3] != 0x0d) )
    {
        psSHP->sHooks.Error( ".shx file is unreadable, or corrupt." );
        psSHP->sHooks.FClose( psSHP->fpSHP );
        psSHP->sHooks.FClose( psSHP->fpSHX );
        free( psSHP );
 
        return( NULL );
    }
 
    psSHP->nRecords = pabyBuf[27] + pabyBuf[26] * 256
        + pabyBuf[25] * 256 * 256 + pabyBuf[24] * 256 * 256 * 256;
    psSHP->nRecords = (psSHP->nRecords*2 - 100) / 8;
 
    psSHP->nShapeType = pabyBuf[32];
 
    if( psSHP->nRecords < 0 || psSHP->nRecords > 256000000 )
    {
        char szError[200];
 
        sprintf( szError,
                 "Record count in .shp header is %d, which seems\n"
                 "unreasonable.  Assuming header is corrupt.",
                 psSHP->nRecords );
        psSHP->sHooks.Error( szError );
        psSHP->sHooks.FClose( psSHP->fpSHP );
        psSHP->sHooks.FClose( psSHP->fpSHX );
        free( psSHP );
        free(pabyBuf);
 
        return( NULL );
    }
 
/* -------------------------------------------------------------------- */
/*      Read the bounds.                                                */
/* -------------------------------------------------------------------- */
    if( bBigEndian ) SwapWord( 8, pabyBuf+36 );
    memcpy( &dValue, pabyBuf+36, 8 );
    psSHP->adBoundsMin[0] = dValue;
 
    if( bBigEndian ) SwapWord( 8, pabyBuf+44 );
    memcpy( &dValue, pabyBuf+44, 8 );
    psSHP->adBoundsMin[1] = dValue;
 
    if( bBigEndian ) SwapWord( 8, pabyBuf+52 );
    memcpy( &dValue, pabyBuf+52, 8 );
    psSHP->adBoundsMax[0] = dValue;
 
    if( bBigEndian ) SwapWord( 8, pabyBuf+60 );
    memcpy( &dValue, pabyBuf+60, 8 );
    psSHP->adBoundsMax[1] = dValue;
 
    if( bBigEndian ) SwapWord( 8, pabyBuf+68 );         /* z */
    memcpy( &dValue, pabyBuf+68, 8 );
    psSHP->adBoundsMin[2] = dValue;
 
    if( bBigEndian ) SwapWord( 8, pabyBuf+76 );
    memcpy( &dValue, pabyBuf+76, 8 );
    psSHP->adBoundsMax[2] = dValue;
 
    if( bBigEndian ) SwapWord( 8, pabyBuf+84 );         /* z */
    memcpy( &dValue, pabyBuf+84, 8 );
    psSHP->adBoundsMin[3] = dValue;
 
    if( bBigEndian ) SwapWord( 8, pabyBuf+92 );
    memcpy( &dValue, pabyBuf+92, 8 );
    psSHP->adBoundsMax[3] = dValue;
 
    free( pabyBuf );
 
/* -------------------------------------------------------------------- */
/*      Read the .shx file to get the offsets to each record in         */
/*      the .shp file.                                                  */
/* -------------------------------------------------------------------- */
    psSHP->nMaxRecords = psSHP->nRecords;
 
    psSHP->panRecOffset = (unsigned int *)
        malloc(sizeof(unsigned int) * MAX(1,psSHP->nMaxRecords) );
    psSHP->panRecSize = (unsigned int *)
        malloc(sizeof(unsigned int) * MAX(1,psSHP->nMaxRecords) );
    pabyBuf = (uchar *) malloc(8 * MAX(1,psSHP->nRecords) );
 
    if (psSHP->panRecOffset == NULL ||
        psSHP->panRecSize == NULL ||
        pabyBuf == NULL)
    {
        char szError[200];
 
        sprintf(szError,
                "Not enough memory to allocate requested memory (nRecords=%d).\n"
                "Probably broken SHP file",
                psSHP->nRecords );
        psSHP->sHooks.Error( szError );
        psSHP->sHooks.FClose( psSHP->fpSHP );
        psSHP->sHooks.FClose( psSHP->fpSHX );
        if (psSHP->panRecOffset) free( psSHP->panRecOffset );
        if (psSHP->panRecSize) free( psSHP->panRecSize );
        if (pabyBuf) free( pabyBuf );
        free( psSHP );
        return( NULL );
    }
 
    if( (int) psSHP->sHooks.FRead( pabyBuf, 8, psSHP->nRecords, psSHP->fpSHX )
        != psSHP->nRecords )
    {
        char szError[200];
 
        sprintf( szError,
                 "Failed to read all values for %d records in .shx file.",
                 psSHP->nRecords );
        psSHP->sHooks.Error( szError );
 
        /* SHX is short or unreadable for some reason. */
        psSHP->sHooks.FClose( psSHP->fpSHP );
        psSHP->sHooks.FClose( psSHP->fpSHX );
        free( psSHP->panRecOffset );
        free( psSHP->panRecSize );
        free( pabyBuf );
        free( psSHP );
 
        return( NULL );
    }
 
    /* In read-only mode, we can close the SHX now */
    if (strcmp(pszAccess, "rb") == 0)
    {
        psSHP->sHooks.FClose( psSHP->fpSHX );
        psSHP->fpSHX = NULL;
    }
 
    for( i = 0; i < psSHP->nRecords; i++ )
    {
        int32           nOffset, nLength;
 
        memcpy( &nOffset, pabyBuf + i * 8, 4 );
        if( !bBigEndian ) SwapWord( 4, &nOffset );
 
        memcpy( &nLength, pabyBuf + i * 8 + 4, 4 );
        if( !bBigEndian ) SwapWord( 4, &nLength );
 
        psSHP->panRecOffset[i] = nOffset*2;
        psSHP->panRecSize[i] = nLength*2;
    }
    free( pabyBuf );
 
    return( psSHP );
}

References SHPInfo::adBoundsMax, SHPInfo::adBoundsMin, bBigEndian, SHPInfo::bUpdated, SAHooks::Error, FALSE, SAHooks::FClose, SAHooks::FOpen, SHPInfo::fpSHP, SHPInfo::fpSHX, SAHooks::FRead, free(), malloc(), MAX, SHPInfo::nFileSize, SHPInfo::nMaxRecords, SHPInfo::nRecords, SHPInfo::nShapeType, SHPInfo::panRecOffset, SHPInfo::panRecSize, SHPInfo::sHooks, SwapWord(), and TRUE.

Referenced by SHPCreateLL(), and SHPOpen().

Here is the call graph for this function:

Here is the caller graph for this function: