dnl Process this file with autoconf to produce a configure script.

dnl $Header: /cvsroot/pgsql/configure.in,v 1.194 2002/07/27 20:10:03 petere Exp $

dnl $Header: /cvsroot/pgsql/configure.in,v 1.195 2002/08/20 17:54:43 petere Exp $

dnl

dnl Developers, please strive to achieve this order:

dnl

[AC_CHECK_FUNCS(on_exit, [],

[AC_MSG_ERROR([neither atexit() nor on_exit() found])])])

AC_FUNC_FSEEKO

# This test makes sure that run tests work at all. Sometimes a shared

# library is found by the linker, but the runtime linker can't find it.

PGAC_FUNC_POSIX_SIGNALS

if test $ac_cv_func_fseeko = yes; then

AC_SYS_LARGEFILE

fi

# Select semaphore implementation type.

<!--

$Header: /cvsroot/pgsql/doc/src/sgml/release.sgml,v 1.148 2002/08/19 19:33:34 tgl Exp $

$Header: /cvsroot/pgsql/doc/src/sgml/release.sgml,v 1.149 2002/08/20 17:54:44 petere Exp $

-->

<appendix id="release">

worries about funny characters.

-->

<literallayout><![CDATA[

Files larger than 2 GB are now supported (if supported by the operating system)

SERIAL no longer implies UNIQUE; specify explicitly if index is wanted

pg_dump -n and -N options have been removed. The new behavior is like -n but knows about key words.

CLUSTER is no longer hazardous to your schema

DataDumperPtrdumpFn,void*dumpArg);

externintWriteData(Archive*AH,constvoid*data,intdLen);

externsize_tWriteData(Archive*AH,constvoid*data,size_tdLen);

WriteData(Archive*AHX,constvoid*data,intdLen)

WriteData(Archive*AHX,constvoid*data,size_tdLen)

{

ArchiveHandle*AH= (ArchiveHandle*)AHX;

(*AH->ArchiveEntryPtr) (AH,newToc);

}

if (AH->lo_buf_used>0)

{

intres;

size_tres;

res=lo_write(AH->connection,AH->loFd, (void*)AH->lo_buf,AH->lo_buf_used);

ahlog(AH,5,"wrote remaining %d bytes of large object data (result = %d)\n",

(int)AH->lo_buf_used,res);

ahlog(AH,5,"wrote remaining %lu bytes of large object data (result = %lu)\n",

(unsigned long)AH->lo_buf_used, (unsigned long)res);

if (res!=AH->lo_buf_used)

die_horribly(AH,modulename,"could not write to large object (result: %d, expected: %d)\n",

res,AH->lo_buf_used);

die_horribly(AH,modulename,"could not write to large object (result: %lu, expected: %lu)\n",

(unsigned long)res, (unsigned long)AH->lo_buf_used);

AH->lo_buf_used=0;

}

ahwrite(constvoid*ptr,size_tsize,size_tnmemb,ArchiveHandle*AH)

{

intres;

size_tres;

if (AH->writingBlob)

{

if(AH->lo_buf_used+size*nmemb>AH->lo_buf_size) {

intremaining=AH->lo_buf_size-AH->lo_buf_used;

intslack=nmemb*size-remaining;

memcpy((char*)AH->lo_buf+AH->lo_buf_used,ptr,remaining);

res=lo_write(AH->connection,AH->loFd,AH->lo_buf,AH->lo_buf_size);

ahlog(AH,5,"wrote %d bytes of large object data (result = %d)\n",

AH->lo_buf_size,res);

if (res!=AH->lo_buf_size)

die_horribly(AH,modulename,"could not write to large object (result: %d, expected: %d)\n",

res,AH->lo_buf_size);

memcpy(AH->lo_buf, (char*)ptr+remaining,slack);

AH->lo_buf_used=slack;

}else {

memcpy((char*)AH->lo_buf+AH->lo_buf_used,ptr,size*nmemb);

AH->lo_buf_used+=size*nmemb;

}

returnsize*nmemb;

if (AH->lo_buf_used+size*nmemb>AH->lo_buf_size)

{

size_tremaining=AH->lo_buf_size-AH->lo_buf_used;

size_tslack=nmemb*size-remaining;

memcpy((char*)AH->lo_buf+AH->lo_buf_used,ptr,remaining);

res=lo_write(AH->connection,AH->loFd,AH->lo_buf,AH->lo_buf_size);

ahlog(AH,5,"wrote %lu bytes of large object data (result = %lu)\n",

(unsigned long)AH->lo_buf_size, (unsigned long)res);

if (res!=AH->lo_buf_size)

die_horribly(AH,modulename,

"could not write to large object (result: %lu, expected: %lu)\n",

(unsigned long)res, (unsigned long)AH->lo_buf_size);

memcpy(AH->lo_buf, (char*)ptr+remaining,slack);

AH->lo_buf_used=slack;

}

{

memcpy((char*)AH->lo_buf+AH->lo_buf_used,ptr,size*nmemb);

AH->lo_buf_used+=size*nmemb;

}

returnsize*nmemb;

}

elseif (AH->gzOut)

{

{

res=fwrite((void*)ptr,size,nmemb,AH->OF);

if (res!=nmemb)

die_horribly(AH,modulename,"could not write to output file (%d != %d)\n",

res, (int)nmemb);

die_horribly(AH,modulename,"could not write to output file (%lu != %lu)\n",

(unsigned long)res, (unsigned long)nmemb);

returnres;

}

}

return_tocEntryRequired(te,ropt);

}

WriteInt(ArchiveHandle*AH,inti)

{

intb;

returnres;

}

WriteStr(ArchiveHandle*AH,constchar*c)

{

intres;

size_tres;

if (c)

{

{

FILE*fh;

charsig[6];/* More than enough */

intcnt;

size_tcnt;

intwantClose=0;

if (ferror(fh))

die_horribly(AH,modulename,"could not read input file: %s\n",strerror(errno));

die_horribly(AH,modulename,"input file is too short (read %d, expected 5)\n",cnt);

die_horribly(AH,modulename,"input file is too short (read %lu, expected 5)\n",

(unsigned long)cnt);

}

}

if (fseek(fh,0,SEEK_SET)!=0)

if (fseeko(fh,0,SEEK_SET)!=0)

{

AH->lookaheadLen=0;/* Don't bother since we've reset the file */

write_msg(modulename,"read %d bytes into lookahead buffer\n",AH->lookaheadLen);

write_msg(modulename,"read %lu bytes into lookahead buffer\n",

(unsigned long)AH->lookaheadLen);

AH->intSize= (*AH->ReadBytePtr) (AH);

if (AH->intSize>32)

die_horribly(AH,modulename,"sanity check on integer size (%d) failed\n",AH->intSize);

die_horribly(AH,modulename,"sanity check on integer size (%lu) failed\n",

(unsigned long)AH->intSize);

if (AH->intSize>sizeof(int))

write_msg(modulename,"WARNING: archive was made on a machine with larger integers, some operations may fail\n");

for (i=0;i <=AH->tocCount+1;i++)

{

tea[i]=te;

for (i=0;i <=AH->tocCount+1;i++)

{

te=te->next;

Oidid2=te2->maxOidVal;

intcmpval;

cmpval=oidcmp(id1,id2);

{

void*next_in;

void*next_out;

intavail_in;

intavail_out;

size_tavail_in;

size_tavail_out;

}z_stream;

typedefz_stream*z_streamp;

typedefvoid (*ArchiveEntryPtr) (struct_archiveHandle*AH,struct_tocEntry*te);

typedefvoid (*StartDataPtr) (struct_archiveHandle*AH,struct_tocEntry*te);

typedefint (*WriteDataPtr) (struct_archiveHandle*AH,constvoid*data,intdLen);

typedefsize_t (*WriteDataPtr) (struct_archiveHandle*AH,constvoid*data,size_tdLen);

typedefvoid (*EndDataPtr) (struct_archiveHandle*AH,struct_tocEntry*te);

typedefvoid (*StartBlobsPtr) (struct_archiveHandle*AH,struct_tocEntry*te);

typedefint (*WriteBytePtr) (struct_archiveHandle*AH,constinti);

typedefint (*ReadBytePtr) (struct_archiveHandle*AH);

typedefint (*WriteBufPtr) (struct_archiveHandle*AH,constvoid*c,intlen);

typedefint (*ReadBufPtr) (struct_archiveHandle*AH,void*buf,intlen);

typedefsize_t (*WriteBufPtr) (struct_archiveHandle*AH,constvoid*c,size_tlen);

typedefsize_t (*ReadBufPtr) (struct_archiveHandle*AH,void*buf,size_tlen);

typedefvoid (*SaveArchivePtr) (struct_archiveHandle*AH);

typedefvoid (*WriteExtraTocPtr) (struct_archiveHandle*AH,struct_tocEntry*te);

typedefvoid (*ReadExtraTocPtr) (struct_archiveHandle*AH,struct_tocEntry*te);

typedefvoid (*PrintExtraTocPtr) (struct_archiveHandle*AH,struct_tocEntry*te);

typedefvoid (*PrintTocDataPtr) (struct_archiveHandle*AH,struct_tocEntry*te,RestoreOptions*ropt);

typedefint (*CustomOutPtr) (struct_archiveHandle*AH,constvoid*buf,intlen);

typedefsize_t (*CustomOutPtr) (struct_archiveHandle*AH,constvoid*buf,size_tlen);

typedefint (*TocSortCompareFn) (constvoid*te1,constvoid*te2);

intdebugLevel;/* Used for logging (currently only by

intintSize;/* Size of an integer in the archive */

size_tintSize;/* Size of an integer in the archive */

ArchiveFormatformat;/* Archive format */

sqlparseInfosqlparse;

char*lookahead;/* Buffer used when reading header to

intlookaheadSize;/* Size of allocated buffer */

intlookaheadLen;/* Length of data in lookahead */

intlookaheadPos;/* Current read position in lookahead

size_tlookaheadSize;/* Size of allocated buffer */

size_tlookaheadLen;/* Length of data in lookahead */

off_tlookaheadPos;/* Current read position in lookahead

ArchiveEntryPtrArchiveEntryPtr;/* Called for each metadata object */

RestoreOptions*ropt;/* Used to check restore options in

void*lo_buf;

intlo_buf_used;

intlo_buf_size;

size_tlo_buf_used;

size_tlo_buf_size;

}ArchiveHandle;

externintWriteInt(ArchiveHandle*AH,inti);

externsize_tWriteInt(ArchiveHandle*AH,inti);

externintReadInt(ArchiveHandle*AH);

externchar*ReadStr(ArchiveHandle*AH);

externintWriteStr(ArchiveHandle*AH,constchar*s);

externsize_tWriteStr(ArchiveHandle*AH,constchar*s);

externvoidStartRestoreBlobs(ArchiveHandle*AH);

externvoidStartRestoreBlob(ArchiveHandle*AH,Oidoid);