greg/stasis-aries-wal
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

No more PBL.

Browse source
This commit is contained in:
Sears Russell 2006-06-20 21:44:17 +00:00
parent bbe16e3a59
commit 6485a4aae9
138 changed files with 10 additions and 21170 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
benchmarks/Makefile.am
View file

@ -1,5 +1,5 @@
LDADD=$(top_builddir)/src/2pc/lib2pc.a $(top_builddir)/src/libdfa/libdfa.a \
$(top_builddir)/src/lladd/liblladd.a $(top_builddir)/src/pbl/libpbl.a \
$(top_builddir)/src/lladd/liblladd.a \
$(top_builddir)/src/libdfa/librw.a
bin_PROGRAMS=lhtableThreaded naiveHash logicalHash readLogicalHash naiveMultiThreaded logicalMultThreaded rawSet \
arrayListSet logicalMultiReaders linearHashNTA linkedListNTA pageOrientedListNTA \

2
configure.in
View file

@ -126,7 +126,6 @@ AC_CONFIG_FILES([Makefile
benchmarks/berkeleyDB/Makefile
libdfa/Makefile
lladd/Makefile
pbl/Makefile
src/2pc/Makefile
src/Makefile
src/apps/Makefile
@ -135,7 +134,6 @@ AC_CONFIG_FILES([Makefile
src/apps/cyrus/Makefile
src/libdfa/Makefile
src/lladd/Makefile
src/pbl/Makefile
src/pobj/Makefile
src/timing/Makefile
test/2pc/Makefile

2
src/Makefile.am
View file

@ -1 +1 @@
SUBDIRS = pbl lladd libdfa 2pc timing pobj apps
SUBDIRS = lladd libdfa 2pc timing pobj apps

1366
src/pbl/ISAM0001.TST
View file

File diff suppressed because it is too large Load diff

177
src/pbl/ISAM0002.TST
View file

@ -1,177 +0,0 @@
###########################################################################
##
## PBL - Program Base Library, Copyright 2002 Peter Graf
##
## This file is part of PBL - The Program Base Library.
## PBL is free software.
##
## This program is free software; you can redistribute it and/or modify
## it under the terms of the GNU General Public License as published by
## the Free Software Foundation; either version 2 of the License, or
## (at your option) any later version.
##
## This program is distributed in the hope that it will be useful,
## but WITHOUT ANY WARRANTY; without even the implied warranty of
## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
## GNU General Public License for more details.
##
## You should have received a copy of the GNU General Public License
## along with this program; if not, write to the Free Software
## Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
##
## For more information on the Program Base Library or Peter Graf,
## please see: http://mission.base.com/.
##
## ISAM file implementation test case, this test case is set up for
## a regression test of the ISAM library, don't change it unless you
## know what you are doing!
##
## 1. Build the pbliftst executable. make all
## 2. Create the sub directory isamtest. mkdir isamtest
## 3. Clear the sub directory isamtest. rm imamtest/*
## 4. Run the test frame on this file. pbliftst ISAM0002.TST
## 5. Compare ISAM0002.TST and pbliftst.log diff ISAM0002.TST pbliftst.log
##
## There should be no differences reported, if so your build of the
## PBL library is most likely ok!
##
###########################################################################
##
## Test case 2
##
## Create a file with 200000 records, close and reopen the file
## and then do a lot of record lookup requests
##
open isamtest/0002main 0002key0,0002dup1,0002key2 1
# pblIsamOpen( isamtest/0002main, 3, 1 )
# ok!
##
## read the first record
##
get 0 FIRST
# pblIsamGet( 4, 0 )
# rc -1, pbl_errno 1003, errno 0
##
## make sure the file is empty
##
ndelete 250000
# pblIsamDelete( 250000 records )
# i 0, rc -1, pbl_errno 1041, errno 0
##
## Insert a lot of records
##
ninsert 200000 key0,duplicatekey1,loooooooooooooooooooooongerkey2 dataaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
# pblIsamInsert( 1, ,key00,duplicatekey10,loooooooooooooooooooooongerkey20, 54, dataaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, 61 )
# inserted 200000 records, rc 0
get 0 FIRST
# pblIsamGet( 4, 0 )
# keylen 5, key key00
get 0 LAST
# pblIsamGet( 5, 0 )
# keylen 9, key key099999
get 1 FIRST
# pblIsamGet( 4, 1 )
# keylen 14, key duplicatekey10
get 1 LAST
# pblIsamGet( 5, 1 )
# keylen 18, key duplicatekey199999
get 2 FIRST
# pblIsamGet( 4, 2 )
# keylen 32, key loooooooooooooooooooooongerkey20
get 2 LAST
# pblIsamGet( 5, 2 )
# keylen 36, key loooooooooooooooooooooongerkey299999
close
# pblIsamClose( 1 )
# rc 0
##
## open the file for reading
##
open isamtest/0002main 0002key0,0002dup1,0002key2 0
# pblIsamOpen( isamtest/0002main, 3, 0 )
# ok!
##
## do a lot of finds
##
get 0 FIRST
# pblIsamGet( 4, 0 )
# keylen 5, key key00
get 0 LAST
# pblIsamGet( 5, 0 )
# keylen 9, key key099999
nfind 200000 0 key0 LT
# pblIsamFind( 1, LT, 0, key0, 4 )
# found 200000 records, rc 0
nfind 200000 0 key0 LE
# pblIsamFind( 1, LE, 0, key0, 4 )
# found 200000 records, rc 0
nfind 200000 0 key0 FI
# pblIsamFind( 1, FI, 0, key0, 4 )
# found 200000 records, rc 0
nfind 200000 0 key0 EQ
# pblIsamFind( 1, EQ, 0, key0, 4 )
# found 200000 records, rc 0
nfind 200000 0 key0 LA
# pblIsamFind( 1, LA, 0, key0, 4 )
# found 200000 records, rc 0
nfind 200000 0 key0 GE
# pblIsamFind( 1, GE, 0, key0, 4 )
# found 200000 records, rc 0
nfind 200000 0 key0 GT
# pblIsamFind( 1, GT, 0, key0, 4 )
# found 200000 records, rc 0
get 1 FIRST
# pblIsamGet( 4, 1 )
# keylen 14, key duplicatekey10
get 1 LAST
# pblIsamGet( 5, 1 )
# keylen 18, key duplicatekey199999
nfind 200000 1 duplicatekey1 LT
# pblIsamFind( 1, LT, 1, duplicatekey1, 13 )
# found 200000 records, rc 0
nfind 200000 1 duplicatekey1 LE
# pblIsamFind( 1, LE, 1, duplicatekey1, 13 )
# found 200000 records, rc 0
nfind 200000 1 duplicatekey1 FI
# pblIsamFind( 1, FI, 1, duplicatekey1, 13 )
# found 200000 records, rc 0
nfind 200000 1 duplicatekey1 EQ
# pblIsamFind( 1, EQ, 1, duplicatekey1, 13 )
# found 200000 records, rc 0
nfind 200000 1 duplicatekey1 LA
# pblIsamFind( 1, LA, 1, duplicatekey1, 13 )
# found 200000 records, rc 0
nfind 200000 1 duplicatekey1 GE
# pblIsamFind( 1, GE, 1, duplicatekey1, 13 )
# found 200000 records, rc 0
nfind 200000 1 duplicatekey1 GT
# pblIsamFind( 1, GT, 1, duplicatekey1, 13 )
# found 200000 records, rc 0
get 2 FIRST
# pblIsamGet( 4, 2 )
# keylen 32, key loooooooooooooooooooooongerkey20
get 2 LAST
# pblIsamGet( 5, 2 )
# keylen 36, key loooooooooooooooooooooongerkey299999
nfind 200000 2 loooooooooooooooooooooongerkey2 LT
# pblIsamFind( 1, LT, 2, loooooooooooooooooooooongerkey2, 31 )
# found 200000 records, rc 0
nfind 200000 2 loooooooooooooooooooooongerkey2 LE
# pblIsamFind( 1, LE, 2, loooooooooooooooooooooongerkey2, 31 )
# found 200000 records, rc 0
nfind 200000 2 loooooooooooooooooooooongerkey2 FI
# pblIsamFind( 1, FI, 2, loooooooooooooooooooooongerkey2, 31 )
# found 200000 records, rc 0
nfind 200000 2 loooooooooooooooooooooongerkey2 EQ
# pblIsamFind( 1, EQ, 2, loooooooooooooooooooooongerkey2, 31 )
# found 200000 records, rc 0
nfind 200000 2 loooooooooooooooooooooongerkey2 LA
# pblIsamFind( 1, LA, 2, loooooooooooooooooooooongerkey2, 31 )
# found 200000 records, rc 0
nfind 200000 2 loooooooooooooooooooooongerkey2 GE
# pblIsamFind( 1, GE, 2, loooooooooooooooooooooongerkey2, 31 )
# found 200000 records, rc 0
nfind 200000 2 loooooooooooooooooooooongerkey2 GT
# pblIsamFind( 1, GT, 2, loooooooooooooooooooooongerkey2, 31 )
# found 200000 records, rc 0
quit

86
src/pbl/ISAM0003.TST
View file

@ -1,86 +0,0 @@
###########################################################################
##
## PBL - Program Base Library, Copyright Peter Graf
##
## This file is part of PBL - The Program Base Library.
## PBL is free software.
##
## This program is free software; you can redistribute it and/or modify
## it under the terms of the GNU General Public License as published by
## the Free Software Foundation; either version 2 of the License, or
## (at your option) any later version.
##
## This program is distributed in the hope that it will be useful,
## but WITHOUT ANY WARRANTY; without even the implied warranty of
## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
## GNU General Public License for more details.
##
## You should have received a copy of the GNU General Public License
## along with this program; if not, write to the Free Software
## Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
##
## For more information on the Program Base Library or Peter Graf,
## please see: http://mission.base.com/.
##
## ISAM file implementation test case
##
## Usage:
## 1. Build the pbliftst executable. make all
## 2. Create the sub directory isamtest. mkdir isamtest
## 3. Clear the sub directory isamtest. rm imamtest/*
## 4. Run the test frame on ISAM0002.TST pbliftst ISAM0002.TST
## 5. Run the test frame on this file. pbliftst ISAM0003.TST
## 6. Compare ISAM0003.TST and pbliftst.log diff ISAM0003.TST pbliftst.log
##
## There should be no differences reported, if so your build of the
## PBL library is most likely ok!
##
###########################################################################
##
## Test case 3, uses output from test case 2
##
## Open a big file
## and then do a lot of record lookup requests
##
## open the file for reading
##
open isamtest/0002main 0002key0,0002dup1,0002key2 0
# pblIsamOpen( isamtest/0002main, 3, 0 )
# ok!
get 0 FIRST
# pblIsamGet( 4, 0 )
# keylen 5, key key00
get 0 LAST
# pblIsamGet( 5, 0 )
# keylen 9, key key099999
get 1 FIRST
# pblIsamGet( 4, 1 )
# keylen 14, key duplicatekey10
get 1 LAST
# pblIsamGet( 5, 1 )
# keylen 18, key duplicatekey199999
get 2 FIRST
# pblIsamGet( 4, 2 )
# keylen 32, key loooooooooooooooooooooongerkey20
get 2 LAST
# pblIsamGet( 5, 2 )
# keylen 36, key loooooooooooooooooooooongerkey299999
##
## do a lot of finds
##
get 1 FIRST
# pblIsamGet( 4, 1 )
# keylen 14, key duplicatekey10
get 1 LAST
# pblIsamGet( 5, 1 )
# keylen 18, key duplicatekey199999
nfind 200000 0 key0 LT
# pblIsamFind( 1, LT, 0, key0, 4 )
# found 200000 records, rc 0
nfind 200000 1 duplicatekey1 LT
# pblIsamFind( 1, LT, 1, duplicatekey1, 13 )
# found 200000 records, rc 0
nfind 200000 2 loooooooooooooooooooooongerkey2 LT
# pblIsamFind( 1, LT, 2, loooooooooooooooooooooongerkey2, 31 )
# found 200000 records, rc 0
quit

406
src/pbl/ISAM0004.TST
View file

@ -1,406 +0,0 @@
###########################################################################
##
## PBL - Program Base Library, Copyright 2002 Peter Graf
##
## This file is part of PBL - The Program Base Library.
## PBL is free software.
##
## This program is free software; you can redistribute it and/or modify
## it under the terms of the GNU General Public License as published by
## the Free Software Foundation; either version 2 of the License, or
## (at your option) any later version.
##
## This program is distributed in the hope that it will be useful,
## but WITHOUT ANY WARRANTY; without even the implied warranty of
## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
## GNU General Public License for more details.
##
## You should have received a copy of the GNU General Public License
## along with this program; if not, write to the Free Software
## Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
##
## For more information on the Program Base Library or Peter Graf,
## please see: http://mission.base.com/.
##
## ISAM file implementation test case, this test case is set up for
## a regression test of the ISAM library, don't change it unless you
## know what you are doing!
##
## Usage:
##
## 1. Build the pbliftst executable. make all
## 2. Create the sub directory isamtest. mkdir isamtest
## 3. Clear the sub directory isamtest. rm imamtest/*
## 4. Run the test frame on this file. pbliftst ISAM0004.TST
## 5. Compare ISAM0004.TST and pbliftst.log diff ISAM0004.TST pbliftst.log
##
## there should be no differences reported, if so your build of the
## PBL library is most likely ok!
##
###########################################################################
##
## Test case 4, tests insert, find, get on duplicate keys
##
## Open the file isam file isamtest/0004main with three index files
## 0004key0, 0004dup1 and 0004key2
## open the file for update, create if necessary
## the index 0004key0 contains unique keys
## the index 0004dup1 can contain duplicate keys,
## ( the test frame allows that because its name contains the string 'dup' )
## the index 0004key2 contains unique keys
##
## open filename keyfile1,dkeyfile2,... update
##
open isamtest/0004main 0004key0,0004dup1,0004key2 1
# pblIsamOpen( isamtest/0004main, 3, 1 )
# ok!
##
## Start a transaction
##
transaction START
# pblIsamStartTransaction( )
# rc 0
##
## Get the first record according to index 0004key0, should report an error
##
## get index < NEXT | PREV | FIRST | LAST | THIS >
##
get 0 FIRST
# pblIsamGet( 4, 0 )
# rc -1, pbl_errno 1003, errno 0
##
## Delete 100000 records, should report an error
##
## ndelete n
##
ndelete 100000
# pblIsamDelete( 100000 records )
# i 0, rc -1, pbl_errno 1041, errno 0
ninsert 2000 key0,dup1,key2 data
# pblIsamInsert( 1, ,key00,dup10,key20, 18, data, 5 )
# inserted 2000 records, rc 0
##
## Read alphabetically last record according to index 0004dup1
## Try reading and searching beyond the last record
##
get 1 LAST
# pblIsamGet( 5, 1 )
# keylen 7, key dup1999
get 0 THIS
# pblIsamGet( 1, 0 )
# keylen 7, key key0999
get 1 NEXT
# pblIsamGet( 2, 1 )
# rc -1, pbl_errno 1003, errno 0
get 0 THIS
# pblIsamGet( 1, 0 )
# keylen 7, key key0999
find 1 dup1999 LA
# pblIsamFind( LA, dup1999, 7 )
# keylen 7, key dup1999
get 0 THIS
# pblIsamGet( 1, 0 )
# keylen 7, key key0999
find 1 dup1999 GE
# pblIsamFind( GE, dup1999, 7 )
# keylen 7, key dup1999
get 0 THIS
# pblIsamGet( 1, 0 )
# keylen 7, key key0999
find 1 dup1999 GT
# pblIsamFind( GT, dup1999, 7 )
# rc -1, pbl_errno 1003, errno 0
get 0 THIS
# pblIsamGet( 1, 0 )
# keylen 7, key key0999
##
## Read alphabetically first record according to index 0004dup1
## Try reading and searching beyond the first record
##
get 1 FIRST
# pblIsamGet( 4, 1 )
# keylen 5, key dup10
get 0 THIS
# pblIsamGet( 1, 0 )
# keylen 5, key key00
get 1 PREV
# pblIsamGet( 3, 1 )
# rc -1, pbl_errno 1003, errno 0
get 0 THIS
# pblIsamGet( 1, 0 )
# keylen 5, key key00
find 1 dup10 FI
# pblIsamFind( FI, dup10, 5 )
# keylen 5, key dup10
get 0 THIS
# pblIsamGet( 1, 0 )
# keylen 5, key key00
find 1 dup10 LE
# pblIsamFind( LE, dup10, 5 )
# keylen 5, key dup10
get 0 THIS
# pblIsamGet( 1, 0 )
# keylen 5, key key00
find 1 dup10 LT
# pblIsamFind( LT, dup10, 5 )
# rc -1, pbl_errno 1003, errno 0
get 0 THIS
# pblIsamGet( 1, 0 )
# keylen 5, key key00
##
## Find a record in the middle and read the records surounding it
##
find 1 dup12 LT
# pblIsamFind( LT, dup12, 5 )
# keylen 8, key dup11999
get 0 THIS
# pblIsamGet( 1, 0 )
# keylen 8, key key01999
get 1 NEXT
# pblIsamGet( 2, 1 )
# keylen 5, key dup12
get 0 THIS
# pblIsamGet( 1, 0 )
# keylen 5, key key02
get 1 NEXT
# pblIsamGet( 2, 1 )
# keylen 6, key dup120
get 0 THIS
# pblIsamGet( 1, 0 )
# keylen 6, key key020
get 1 NEXT
# pblIsamGet( 2, 1 )
# keylen 7, key dup1200
get 0 THIS
# pblIsamGet( 1, 0 )
# keylen 7, key key0200
##
## Test all possible find operations on an inner record
##
find 1 dup12 LT
# pblIsamFind( LT, dup12, 5 )
# keylen 8, key dup11999
get 0 THIS
# pblIsamGet( 1, 0 )
# keylen 8, key key01999
find 1 dup12 LE
# pblIsamFind( LE, dup12, 5 )
# keylen 5, key dup12
get 0 THIS
# pblIsamGet( 1, 0 )
# keylen 5, key key02
find 1 dup12 FI
# pblIsamFind( FI, dup12, 5 )
# keylen 5, key dup12
get 0 THIS
# pblIsamGet( 1, 0 )
# keylen 5, key key02
find 1 dup12 EQ
# pblIsamFind( EQ, dup12, 5 )
# keylen 5, key dup12
get 0 THIS
# pblIsamGet( 1, 0 )
# keylen 5, key key02
find 1 dup12 LA
# pblIsamFind( LA, dup12, 5 )
# keylen 5, key dup12
get 0 THIS
# pblIsamGet( 1, 0 )
# keylen 5, key key02
find 1 dup12 GE
# pblIsamFind( GE, dup12, 5 )
# keylen 5, key dup12
get 0 THIS
# pblIsamGet( 1, 0 )
# keylen 5, key key02
find 1 dup12 GT
# pblIsamFind( GT, dup12, 5 )
# keylen 6, key dup120
get 0 THIS
# pblIsamGet( 1, 0 )
# keylen 6, key key020
##
## Tnsert two records with a duplicate key
##
insert ,key1insert1,dup12,key2insert1 data1
# pblIsamInsert( 1, ,key1insert1,dup12,key2insert1, 30, data1, 6 )
# rc 0
insert ,key1insert2,dup12,key2insert2 data1
# pblIsamInsert( 1, ,key1insert2,dup12,key2insert2, 30, data1, 6 )
# rc 0
get 0 THIS
# pblIsamGet( 1, 0 )
# keylen 11, key key1insert2
##
## Test the find operations on the records with duplicate keys
##
find 1 dup12 LT
# pblIsamFind( LT, dup12, 5 )
# keylen 8, key dup11999
get 0 THIS
# pblIsamGet( 1, 0 )
# keylen 8, key key01999
find 1 dup12 LE
# pblIsamFind( LE, dup12, 5 )
# keylen 5, key dup12
get 0 THIS
# pblIsamGet( 1, 0 )
# keylen 5, key key02
find 1 dup12 FI
# pblIsamFind( FI, dup12, 5 )
# keylen 5, key dup12
get 0 THIS
# pblIsamGet( 1, 0 )
# keylen 5, key key02
get 1 NEXT
# pblIsamGet( 2, 1 )
# keylen 5, key dup12
get 0 THIS
# pblIsamGet( 1, 0 )
# keylen 11, key key1insert1
get 1 NEXT
# pblIsamGet( 2, 1 )
# keylen 5, key dup12
get 0 THIS
# pblIsamGet( 1, 0 )
# keylen 11, key key1insert2
get 1 NEXT
# pblIsamGet( 2, 1 )
# keylen 6, key dup120
get 0 THIS
# pblIsamGet( 1, 0 )
# keylen 6, key key020
find 1 dup12 EQ
# pblIsamFind( EQ, dup12, 5 )
# keylen 5, key dup12
get 0 THIS
# pblIsamGet( 1, 0 )
# keylen 5, key key02
find 1 dup12 LA
# pblIsamFind( LA, dup12, 5 )
# keylen 5, key dup12
get 0 THIS
# pblIsamGet( 1, 0 )
# keylen 11, key key1insert2
find 1 dup12 GE
# pblIsamFind( GE, dup12, 5 )
# keylen 5, key dup12
get 0 THIS
# pblIsamGet( 1, 0 )
# keylen 11, key key1insert2
find 1 dup12 GT
# pblIsamFind( GT, dup12, 5 )
# keylen 6, key dup120
get 0 THIS
# pblIsamGet( 1, 0 )
# keylen 6, key key020
##
## Delete the three records with duplicate key dup150
##
find 1 dup12 FI
# pblIsamFind( FI, dup12, 5 )
# keylen 5, key dup12
get 0 THIS
# pblIsamGet( 1, 0 )
# keylen 5, key key02
ndelete 1
# pblIsamDelete( 1 records )
# deleted 1 records, rc 0
find 1 dup12 FI
# pblIsamFind( FI, dup12, 5 )
# keylen 5, key dup12
get 0 THIS
# pblIsamGet( 1, 0 )
# keylen 11, key key1insert1
ndelete 1
# pblIsamDelete( 1 records )
# deleted 1 records, rc 0
find 1 dup12 FI
# pblIsamFind( FI, dup12, 5 )
# keylen 5, key dup12
get 0 THIS
# pblIsamGet( 1, 0 )
# keylen 11, key key1insert2
ndelete 1
# pblIsamDelete( 1 records )
# deleted 1 records, rc 0
get 0 THIS
# pblIsamGet( 1, 0 )
# keylen 8, key key01999
##
## Test the find operations on the deleted records with duplicate keys
##
find 1 dup12 LT
# pblIsamFind( LT, dup12, 5 )
# keylen 8, key dup11999
get 0 THIS
# pblIsamGet( 1, 0 )
# keylen 8, key key01999
find 1 dup12 LE
# pblIsamFind( LE, dup12, 5 )
# keylen 8, key dup11999
get 0 THIS
# pblIsamGet( 1, 0 )
# keylen 8, key key01999
find 1 dup12 FI
# pblIsamFind( FI, dup12, 5 )
# rc -1, pbl_errno 1003, errno 0
get 0 THIS
# pblIsamGet( 1, 0 )
# keylen 8, key key01999
find 1 dup12 EQ
# pblIsamFind( EQ, dup12, 5 )
# rc -1, pbl_errno 1003, errno 0
get 0 THIS
# pblIsamGet( 1, 0 )
# keylen 8, key key01999
find 1 dup12 LA
# pblIsamFind( LA, dup12, 5 )
# rc -1, pbl_errno 1003, errno 0
get 0 THIS
# pblIsamGet( 1, 0 )
# keylen 8, key key01999
find 1 dup12 GE
# pblIsamFind( GE, dup12, 5 )
# keylen 6, key dup120
get 0 THIS
# pblIsamGet( 1, 0 )
# keylen 6, key key020
find 1 dup12 GT
# pblIsamFind( GT, dup12, 5 )
# keylen 6, key dup120
get 0 THIS
# pblIsamGet( 1, 0 )
# keylen 6, key key020
##
## Delete 1999 records, i.e. all of them
##
ndelete 1999
# pblIsamDelete( 1999 records )
# deleted 1999 records, rc 0
##
## Verify the file is empty now
##
get 0 FIRST
# pblIsamGet( 4, 0 )
# rc -1, pbl_errno 1003, errno 0
get 1 FIRST
# pblIsamGet( 4, 1 )
# rc -1, pbl_errno 1003, errno 0
get 2 FIRST
# pblIsamGet( 4, 2 )
# rc -1, pbl_errno 1003, errno 0
##
## Rollback the transaction, the inserts that happened
## after the transaction started are NOT committed
##
transaction ROLLBACK
# pblIsamCommit( ROLLBACK )
# rc 1, pbl_errno 0, errno 0
##
## Close the file
##
close
# pblIsamClose( 1 )
# rc 0
quit

322
src/pbl/ISAM0005.TST
View file

@ -1,322 +0,0 @@
###########################################################################
##
## PBL - Program Base Library, Copyright Peter Graf
##
## This file is part of PBL - The Program Base Library.
## PBL is free software.
##
## This program is free software; you can redistribute it and/or modify
## it under the terms of the GNU General Public License as published by
## the Free Software Foundation; either version 2 of the License, or
## (at your option) any later version.
##
## This program is distributed in the hope that it will be useful,
## but WITHOUT ANY WARRANTY; without even the implied warranty of
## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
## GNU General Public License for more details.
##
## You should have received a copy of the GNU General Public License
## along with this program; if not, write to the Free Software
## Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
##
## For more information on the Program Base Library or Peter Graf,
## please see: http://mission.base.com/.
##
## ISAM file implementation test case, this test case is set up for
## a regression test of the ISAM library, don't change it unless you
## know what you are doing!
##
## Usage:
##
## 1. Build the pbliftst executable. make all
## 2. Create the sub directory isamtest. mkdir isamtest
## 3. Clear the sub directory isamtest. rm imamtest/*
## 4. Run the test frame on this file. pbliftst ISAM0005.TST
## 5. Compare ISAM0005.TST and pbliftst.log diff ISAM0005.TST pbliftst.log
##
## There should be no differences reported, if so your build of the
## PBL library is most likely ok!
##
###########################################################################
##
## Test case 5
##
## Create a file with 2000000 records,
## and then do some lookup requests
##
## !!!!! NOTE !!!! Test needs 700 Megabytes of disc space
##
open isamtest/0005main 0005key0,0005dup1,0005key2 1
# pblIsamOpen( isamtest/0005main, 3, 1 )
# ok!
##
## read the first record
##
get 0 FIRST
# pblIsamGet( 4, 0 )
# rc -1, pbl_errno 1003, errno 0
ndelete 2500000
# pblIsamDelete( 2500000 records )
# i 0, rc -1, pbl_errno 1041, errno 0
##
## Insert a lot of records
##
ninsert 2000000 key0,duplicatekey1,loooooooooooooooooooooongerkey2 dataaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
# pblIsamInsert( 1, ,key00,duplicatekey10,loooooooooooooooooooooongerkey20, 54, dataaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, 61 )
# inserted 2000000 records, rc 0
get -1 FIRST
# pblIsamGet( 4, -1 )
# keylen 0, key
datalen
# pblIsamReadDatalen( currentrecord )
# datalen 61
readkey 0
# pblIsamReadKey( currentrecord, 0 )
# keylen 5, key key00
get -1 PREV
# pblIsamGet( 3, -1 )
# rc -1, pbl_errno 1003, errno 0
datalen
# pblIsamReadDatalen( currentrecord )
# datalen 61
readkey 0
# pblIsamReadKey( currentrecord, 0 )
# keylen 5, key key00
get -1 NEXT
# pblIsamGet( 2, -1 )
# keylen 0, key
datalen
# pblIsamReadDatalen( currentrecord )
# datalen 61
readkey 0
# pblIsamReadKey( currentrecord, 0 )
# keylen 5, key key01
get -1 THIS
# pblIsamGet( 1, -1 )
# keylen 0, key
datalen
# pblIsamReadDatalen( currentrecord )
# datalen 61
readkey 0
# pblIsamReadKey( currentrecord, 0 )
# keylen 5, key key01
get -1 LAST
# pblIsamGet( 5, -1 )
# keylen 0, key
datalen
# pblIsamReadDatalen( currentrecord )
# datalen 61
readkey 0
# pblIsamReadKey( currentrecord, 0 )
# keylen 11, key key01999999
get -1 NEXT
# pblIsamGet( 2, -1 )
# rc -1, pbl_errno 1003, errno 0
datalen
# pblIsamReadDatalen( currentrecord )
# datalen 61
readkey 0
# pblIsamReadKey( currentrecord, 0 )
# keylen 11, key key01999999
get -1 PREV
# pblIsamGet( 3, -1 )
# keylen 0, key
datalen
# pblIsamReadDatalen( currentrecord )
# datalen 61
readkey 0
# pblIsamReadKey( currentrecord, 0 )
# keylen 11, key key01999998
get 0 FIRST
# pblIsamGet( 4, 0 )
# keylen 5, key key00
get 0 PREV
# pblIsamGet( 3, 0 )
# rc -1, pbl_errno 1003, errno 0
get 0 NEXT
# pblIsamGet( 2, 0 )
# keylen 5, key key01
get 0 NEXT
# pblIsamGet( 2, 0 )
# keylen 6, key key010
get 0 LAST
# pblIsamGet( 5, 0 )
# keylen 10, key key0999999
get 0 NEXT
# pblIsamGet( 2, 0 )
# rc -1, pbl_errno 1003, errno 0
get 0 PREV
# pblIsamGet( 3, 0 )
# keylen 10, key key0999998
get 0 PREV
# pblIsamGet( 3, 0 )
# keylen 10, key key0999997
get 1 FIRST
# pblIsamGet( 4, 1 )
# keylen 14, key duplicatekey10
get 1 PREV
# pblIsamGet( 3, 1 )
# rc -1, pbl_errno 1003, errno 0
get 1 NEXT
# pblIsamGet( 2, 1 )
# keylen 14, key duplicatekey11
get 1 NEXT
# pblIsamGet( 2, 1 )
# keylen 15, key duplicatekey110
get 1 LAST
# pblIsamGet( 5, 1 )
# keylen 19, key duplicatekey1999999
get 1 NEXT
# pblIsamGet( 2, 1 )
# rc -1, pbl_errno 1003, errno 0
get 1 PREV
# pblIsamGet( 3, 1 )
# keylen 19, key duplicatekey1999998
get 1 PREV
# pblIsamGet( 3, 1 )
# keylen 19, key duplicatekey1999997
get 2 FIRST
# pblIsamGet( 4, 2 )
# keylen 32, key loooooooooooooooooooooongerkey20
get 2 PREV
# pblIsamGet( 3, 2 )
# rc -1, pbl_errno 1003, errno 0
get 2 NEXT
# pblIsamGet( 2, 2 )
# keylen 32, key loooooooooooooooooooooongerkey21
get 2 NEXT
# pblIsamGet( 2, 2 )
# keylen 33, key loooooooooooooooooooooongerkey210
get 2 LAST
# pblIsamGet( 5, 2 )
# keylen 37, key loooooooooooooooooooooongerkey2999999
get 2 NEXT
# pblIsamGet( 2, 2 )
# rc -1, pbl_errno 1003, errno 0
get 2 PREV
# pblIsamGet( 3, 2 )
# keylen 37, key loooooooooooooooooooooongerkey2999998
get 2 PREV
# pblIsamGet( 3, 2 )
# keylen 37, key loooooooooooooooooooooongerkey2999997
##
## do some finds in the middle of the file
##
find 0 key02 LT
# pblIsamFind( LT, key02, 5 )
# keylen 11, key key01999999
get 0 PREV
# pblIsamGet( 3, 0 )
# keylen 11, key key01999998
get 0 NEXT
# pblIsamGet( 2, 0 )
# keylen 11, key key01999999
get 0 NEXT
# pblIsamGet( 2, 0 )
# keylen 5, key key02
get 0 NEXT
# pblIsamGet( 2, 0 )
# keylen 6, key key020
find 0 key02 LE
# pblIsamFind( LE, key02, 5 )
# keylen 5, key key02
find 0 key02 FI
# pblIsamFind( FI, key02, 5 )
# keylen 5, key key02
find 0 key02 EQ
# pblIsamFind( EQ, key02, 5 )
# keylen 5, key key02
find 0 key02 LA
# pblIsamFind( LA, key02, 5 )
# keylen 5, key key02
find 0 key02 GE
# pblIsamFind( GE, key02, 5 )
# keylen 5, key key02
find 0 key02 GT
# pblIsamFind( GT, key02, 5 )
# keylen 6, key key020
find 1 duplicatekey12 LT
# pblIsamFind( LT, duplicatekey12, 14 )
# keylen 20, key duplicatekey11999999
get 1 PREV
# pblIsamGet( 3, 1 )
# keylen 20, key duplicatekey11999998
get 1 NEXT
# pblIsamGet( 2, 1 )
# keylen 20, key duplicatekey11999999
get 1 NEXT
# pblIsamGet( 2, 1 )
# keylen 14, key duplicatekey12
get 1 NEXT
# pblIsamGet( 2, 1 )
# keylen 15, key duplicatekey120
find 1 duplicatekey12 LE
# pblIsamFind( LE, duplicatekey12, 14 )
# keylen 14, key duplicatekey12
find 1 duplicatekey12 FI
# pblIsamFind( FI, duplicatekey12, 14 )
# keylen 14, key duplicatekey12
find 1 duplicatekey12 EQ
# pblIsamFind( EQ, duplicatekey12, 14 )
# keylen 14, key duplicatekey12
find 1 duplicatekey12 LA
# pblIsamFind( LA, duplicatekey12, 14 )
# keylen 14, key duplicatekey12
find 1 duplicatekey12 GE
# pblIsamFind( GE, duplicatekey12, 14 )
# keylen 14, key duplicatekey12
find 1 duplicatekey12 GT
# pblIsamFind( GT, duplicatekey12, 14 )
# keylen 15, key duplicatekey120
find 2 loooooooooooooooooooooongerkey22 LT
# pblIsamFind( LT, loooooooooooooooooooooongerkey22, 32 )
# keylen 38, key loooooooooooooooooooooongerkey21999999
get 2 PREV
# pblIsamGet( 3, 2 )
# keylen 38, key loooooooooooooooooooooongerkey21999998
get 2 NEXT
# pblIsamGet( 2, 2 )
# keylen 38, key loooooooooooooooooooooongerkey21999999
get 2 NEXT
# pblIsamGet( 2, 2 )
# keylen 32, key loooooooooooooooooooooongerkey22
get 2 NEXT
# pblIsamGet( 2, 2 )
# keylen 33, key loooooooooooooooooooooongerkey220
find 2 loooooooooooooooooooooongerkey22 LE
# pblIsamFind( LE, loooooooooooooooooooooongerkey22, 32 )
# keylen 32, key loooooooooooooooooooooongerkey22
find 2 loooooooooooooooooooooongerkey22 FI
# pblIsamFind( FI, loooooooooooooooooooooongerkey22, 32 )
# keylen 32, key loooooooooooooooooooooongerkey22
find 2 loooooooooooooooooooooongerkey22 EQ
# pblIsamFind( EQ, loooooooooooooooooooooongerkey22, 32 )
# keylen 32, key loooooooooooooooooooooongerkey22
find 2 loooooooooooooooooooooongerkey22 LA
# pblIsamFind( LA, loooooooooooooooooooooongerkey22, 32 )
# keylen 32, key loooooooooooooooooooooongerkey22
find 2 loooooooooooooooooooooongerkey22 GE
# pblIsamFind( GE, loooooooooooooooooooooongerkey22, 32 )
# keylen 32, key loooooooooooooooooooooongerkey22
find 2 loooooooooooooooooooooongerkey22 GT
# pblIsamFind( GT, loooooooooooooooooooooongerkey22, 32 )
# keylen 33, key loooooooooooooooooooooongerkey220
##
## More finds at the start of the file
##
find 0 key00 LT
# pblIsamFind( LT, key00, 5 )
# rc -1, pbl_errno 1003, errno 0
find 0 key00 LE
# pblIsamFind( LE, key00, 5 )
# keylen 5, key key00
find 0 key00 FI
# pblIsamFind( FI, key00, 5 )
# keylen 5, key key00
get 0 PREV
# pblIsamGet( 3, 0 )
# rc -1, pbl_errno 1003, errno 0
close
# pblIsamClose( 1 )
# rc 0
quit

5
src/pbl/Makefile.am
View file

@ -1,5 +0,0 @@
# TODO: Doesn't build the pbl tests..
lib_LIBRARIES=libpbl.a
libpbl_a_SOURCES=#pblhash.c #pbl.c pblhash.c #pblkf.c pblisam.c
# jbhash.c
AM_CFLAGS= -g -Wall -pedantic -std=gnu99

7
src/pbl/README.DOC
View file

@ -1,7 +0,0 @@
The documentation for PBL was created with docpp.
The command to create it is:
docxx -H --dir doc pbl.dxx

3
src/pbl/classFooter.inc
View file

@ -1,3 +0,0 @@
<hr>
Copyright(C) 2003 Peter Graf, this software is distributed under the
<a href="http://www.gnu.org/">GNU</a> Lesser General Public License

3
src/pbl/classHeader.inc
View file

@ -1,3 +0,0 @@
<center>
<H2>Program Base Library Functions</H2>
</center>

90
src/pbl/doc/AIntroduction.html
View file

@ -1,90 +0,0 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML>
<HEAD>
<TITLE>#define A: Introduction</TITLE>
<META NAME="GENERATOR" CONTENT="DOC++ 3.4.9">
</HEAD>
<center>
<H2>Program Base Library Functions</H2>
</center>
<H2>#define <A HREF="#DOC.DOCU">A: Introduction</A></H2></H2><A NAME="DOC.DOCU"></A>
<BLOCKQUOTE>
PBL is a C library of functions that can be used in a C or C++ project.
PBL is highly portable and compiles warning free on Linux gcc, Windows
Cygwin gcc and Windows Microsoft Visual C++, V 6.0.
<P><P>
<H2>VERSIONS:</H2>
<UL>
<B>Version 1.00, Thu Sep 5 2002</B> - initial version
<P>
<B>Version 1.01, Fri Nov 1 2002</B> - improved memory management, see pblkf.c Revision 1.2, 1.3
<P>
<B>Version 1.02, Mit Feb 19 2003</B> - fixed a bug reported by Csaba Pálos, see pblisam.c Revision 1.2
</UL>
<P><P>
<H2>CODE:</H2>
<UL>
The code of the PBL library includes:
<P>
<B>PBL BASE</B> - some base functions,
see <B>pbl_*</B> functions,
<P>
<B>PBL HASH</B> - an open source memory hash table implementation,
see <B>pblHt*</B> functions,
<UL>
<B>Features</B>
<UL>
<LI>random access lookups
<LI>sequential access
<LI>regression test frame
</UL>
</UL>
<B>PBL KEYFILE</B> - an open source key file implementation,
see <B>pblKf*</B> functions,
<UL>
<B>Features</B>
<UL>
<LI>ultra fast B* tree implementation for random lookups
<LI>transaction handling
<LI>sequential access methods
<LI>embedable small footprint, < 35 Kb
<LI>arbitrary size files, up to 4 terrabytes
<LI>arbitrary number of records per file, up to 2 ^^ 48 records
<LI>duplicate keys
<LI>advanced key compression for minimal size B trees
<LI>keylength up to 255 bytes
<LI>regression test frame
</UL>
</UL>
<B>PBL ISAM</B> - an open source ISAM file implementation,
see <B>pblIsam*</B> functions
<UL>
<B>Features</B>
<UL>
<LI>ultra fast B* tree implementation for random lookups
<LI>transaction handling
<LI>sequential access methods
<LI>embedable small footprint, < 75 Kb
<LI>arbitrary size files, up to 4 terrabytes
<LI>arbitrary number of records per file, up to 2 ^^ 48 records
<LI>duplicate keys and unique keys
<LI>advanced key compression for minimal size index files
<LI>keylength up to 255 bytes per index
<LI>keylength up to 1024 per record
<LI>regression test frame
</UL>
</UL>
</UL>
</BLOCKQUOTE>
<DL><DT><DD></DL><P> <hr>
Copyright(C) 2002 Peter Graf, this software is distributed under the
<a href="http://www.gnu.org/">GNU</a> Lesser General Public License
<HR>
<BR>
This page was generated with the help of <A HREF="http://docpp.sourceforge.net">DOC++</A>.
</BODY>
</HTML>

53
src/pbl/doc/BFiles.html
View file

@ -1,53 +0,0 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML>
<HEAD>
<TITLE>#define B: Files</TITLE>
<META NAME="GENERATOR" CONTENT="DOC++ 3.4.9">
</HEAD>
<center>
<H2>Program Base Library Functions</H2>
</center>
<H2>#define <A HREF="#DOC.DOCU">B: Files</A></H2></H2><A NAME="DOC.DOCU"></A>
<BLOCKQUOTE>list of files of component
<P>
<B>FILES</B>
<UL>
<LI> <a href="../pbl.h">pbl.h</a> - the include file of the library
<LI> <a href="../pbl.c">pbl.c</a> - source for the base functions
<LI> <a href="../pblhash.c">pblhash.c</a> - source file for the
hash functions
<LI> <a href="../pblhttst.c">pblhttst.c</a> - source file for the
hash function test frame
<LI> <a href="../pblkf.c">pblkf.c</a> - source file for the key
file functions
<LI> <a href="../pblkftst.c">pblkftst.c</a> - source file for the
key file handling test frame
<LI> <a href="../pblisam.c">pblisam.c</a> - source file for the isam
file functions
<LI> <a href="../pbliftst.c">pbliftst.c</a> - source file for the
isam file handling test frame
<LI> <a href="../makefile">makefile</a> - a Unix makefile for the
component
<LI> <a href="../pblhttstdeb.dsp">pblhttstdeb.dsp</a> - a Microsoft Visual
Studio 6.0 project file for
hash table debug
<LI> <a href="../pblkftstdeb.dsp">pblkftstdeb.dsp</a> - a Microsoft
Visual Studio 6.0 project file
for key file debug
<LI> <a href="../pbliftstdeb.dsp">pbliftstdeb.dsp</a> - a Microsoft Visual
Studio 6.0 project file for
isam file debug
<LI> <a href="../ISAM0001.LOG">ISAM0001.LOG</a> - a test case for the
isam file handling test frame
<LI> <a href="../pbl.dxx">pbl.dxx</a> - the source for this document
</UL></BLOCKQUOTE>
<DL><DT><DD></DL><P> <hr>
Copyright(C) 2002 Peter Graf, this software is distributed under the
<a href="http://www.gnu.org/">GNU</a> Lesser General Public License
<HR>
<BR>
This page was generated with the help of <A HREF="http://docpp.sourceforge.net">DOC++</A>.
</BODY>
</HTML>

41
src/pbl/doc/CErrorcodes.html
View file

@ -1,41 +0,0 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML>
<HEAD>
<TITLE>#define C: Error codes</TITLE>
<META NAME="GENERATOR" CONTENT="DOC++ 3.4.9">
</HEAD>
<center>
<H2>Program Base Library Functions</H2>
</center>
<H2>#define <A HREF="#DOC.DOCU">C: Error codes</A></H2></H2><A NAME="DOC.DOCU"></A>
<BLOCKQUOTE>error codes of the pbl library
<P></BLOCKQUOTE>
<DL><DT><DT><B>Fields:</B><DD><B>PBL_ERROR_OUT_OF_MEMORY</B> - out of memory
<BR><B>PBL_ERROR_EXISTS</B> - record already exists
<BR><B>PBL_ERROR_NOT_FOUND</B> - record not found
<BR><B>PBL_ERROR_BAD_FILE</B> - file structure damaged
<BR><B>PBL_ERROR_PARAM_MODE</B> - parameter mode is not valid
<BR><B>PBL_ERROR_PARAM_KEY</B> - parameter key is not valid
<BR><B>PBL_ERROR_PARAM_KEYLEN</B> - parameter keylen is not valid
<BR><B>PBL_ERROR_PARAM_DATA</B> - parameter data is not valid
<BR><B>PBL_ERROR_PARAM_DATALEN</B> - parameter datalen is not valid
<BR><B>PBL_ERROR_PARAM_INDEX</B> - parameter index is not valid
<BR><B>PBL_ERROR_CREATE</B> - file system create error, see errno
<BR><B>PBL_ERROR_OPEN</B> - file system open error, see errno
<BR><B>PBL_ERROR_SEEK</B> - file system seek error, see errno
<BR><B>PBL_ERROR_READ</B> - file system read error, see errno
<BR><B>PBL_ERROR_WRITE</B> - file system write error, see errno
<BR><B>PBL_ERROR_PROGRAM</B> - an internal error in the code, debug it!!
<BR><B>PBL_ERROR_NOFIT</B> - internal error forcing a block split
<BR><B>PBL_ERROR_NOT_ALLOWED</B> - file not open for update, operation not allowed
<BR><B>PBL_ERROR_POSITION</B> - current record is not positioned<BR><DD></DL><P> <hr>
Copyright(C) 2002 Peter Graf, this software is distributed under the
<a href="http://www.gnu.org/">GNU</a> Lesser General Public License
<HR>
<BR>
This page was generated with the help of <A HREF="http://docpp.sourceforge.net">DOC++</A>.
</BODY>
</HTML>

28
src/pbl/doc/DDefinitionsforKeyFileParameters.html
View file

@ -1,28 +0,0 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML>
<HEAD>
<TITLE>#define D: Definitions for Key File Parameters</TITLE>
<META NAME="GENERATOR" CONTENT="DOC++ 3.4.9">
</HEAD>
<center>
<H2>Program Base Library Functions</H2>
</center>
<H2>#define <A HREF="#DOC.DOCU">D: Definitions for Key File Parameters</A></H2></H2><A NAME="DOC.DOCU"></A>
<BLOCKQUOTE>DEFINES FOR PARAMETER <B> mode </B> OF <!1><A HREF="pblKfFind.html">pblKfFind</A>()
</BLOCKQUOTE>
<DL><DT><DT><B>Fields:</B><DD><B>PBLEQ</B> - any record that is equal
<BR><B>PBLFI</B> - first record that is equal
<BR><B>PBLLA</B> - last record that is equal
<BR><B>PBLGE</B> - last equal or first that is greater
<BR><B>PBLGT</B> - first that is greater
<BR><B>PBLLE</B> - first equal or last that is smaller
<BR><B>PBLLT</B> - last that is smaller<BR><DD></DL><P> <hr>
Copyright(C) 2002 Peter Graf, this software is distributed under the
<a href="http://www.gnu.org/">GNU</a> Lesser General Public License
<HR>
<BR>
This page was generated with the help of <A HREF="http://docpp.sourceforge.net">DOC++</A>.
</BODY>
</HTML>

26
src/pbl/doc/EDefinitionsforISAMParameters.html
View file

@ -1,26 +0,0 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML>
<HEAD>
<TITLE>#define E: Definitions for ISAM Parameters</TITLE>
<META NAME="GENERATOR" CONTENT="DOC++ 3.4.9">
</HEAD>
<center>
<H2>Program Base Library Functions</H2>
</center>
<H2>#define <A HREF="#DOC.DOCU">E: Definitions for ISAM Parameters</A></H2></H2><A NAME="DOC.DOCU"></A>
<BLOCKQUOTE>DEFINES FOR PARAMETER <B> which </B> OF <!1><A HREF="pblIsamGet.html">pblIsamGet</A>()
</BLOCKQUOTE>
<DL><DT><DT><B>Fields:</B><DD><B>PBLTHIS</B> - get key and keylen of current record
<BR><B>PBLNEXT</B> - get key and keylen of next record
<BR><B>PBLPREV</B> - get key and keylen of previous record
<BR><B>PBLFIRST</B> - get key and keylen of first record
<BR><B>PBLLAST</B> - get key and keylen of last record<BR><DD></DL><P> <hr>
Copyright(C) 2002 Peter Graf, this software is distributed under the
<a href="http://www.gnu.org/">GNU</a> Lesser General Public License
<HR>
<BR>
This page was generated with the help of <A HREF="http://docpp.sourceforge.net">DOC++</A>.
</BODY>
</HTML>

19
src/pbl/doc/General.html
View file

@ -1,19 +0,0 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML>
<HEAD>
<TITLE>General Bits</TITLE>
<META NAME="GENERATOR" CONTENT="DOC++ 3.4.9">
</HEAD>
<BODY BGCOLOR="#ffffff">
<DL>
</DL>
<hr>
Copyright(C) 2002 Peter Graf, this software is distributed under the
<a href="http://www.gnu.org/">GNU</a> Lesser General Public License
<HR>
<BR>
This page was generated with the help of <A HREF="http://docpp.sourceforge.net">DOC++</A>.
</BODY>
</HTML>

25
src/pbl/doc/PBLDATALENGTH.html
View file

@ -1,25 +0,0 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML>
<HEAD>
<TITLE>#define PBLDATALENGTH</TITLE>
<META NAME="GENERATOR" CONTENT="DOC++ 3.4.9">
</HEAD>
<center>
<H2>Program Base Library Functions</H2>
</center>
<H2>#define <A HREF="#DOC.DOCU">PBLDATALENGTH</A></H2></H2><BLOCKQUOTE> maximum data length of data being stored on index blocks of key files, </BLOCKQUOTE>
<A NAME="DOC.DOCU"></A>
<HR>
<H2>Documentation</H2>
<BLOCKQUOTE>
maximum data length of data being stored on index blocks of key files,
maximum length of data stored with an item on the level 0 block, 1024
data that is longer is stored on data blocks.</BLOCKQUOTE>
<DL><DT><DD></DL><P><P><I><A HREF="index.html">Alphabetic index</A></I></P><HR>
<BR>
This page was generated with the help of <A HREF="http://docpp.sourceforge.net">DOC++</A>.
</BODY>
</HTML>

24
src/pbl/doc/PBLKEYLENGTH.html
View file

@ -1,24 +0,0 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML>
<HEAD>
<TITLE>#define PBLKEYLENGTH</TITLE>
<META NAME="GENERATOR" CONTENT="DOC++ 3.4.9">
</HEAD>
<center>
<H2>Program Base Library Functions</H2>
</center>
<H2>#define <A HREF="#DOC.DOCU">PBLKEYLENGTH</A></H2></H2><BLOCKQUOTE> the maximum length of a key of the key file component, </BLOCKQUOTE>
<A NAME="DOC.DOCU"></A>
<HR>
<H2>Documentation</H2>
<BLOCKQUOTE>
the maximum length of a key of the key file component,
maximum length of a key, 255 for now</BLOCKQUOTE>
<DL><DT><DD></DL><P><P><I><A HREF="index.html">Alphabetic index</A></I></P><HR>
<BR>
This page was generated with the help of <A HREF="http://docpp.sourceforge.net">DOC++</A>.
</BODY>
</HTML>

24
src/pbl/doc/PBL_FREE.html
View file

@ -1,24 +0,0 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML>
<HEAD>
<TITLE>#define PBL_FREE</TITLE>
<META NAME="GENERATOR" CONTENT="DOC++ 3.4.9">
</HEAD>
<center>
<H2>Program Base Library Functions</H2>
</center>
<H2>#define <A HREF="#DOC.DOCU">PBL_FREE</A></H2><H2>( ptr )</H2><BLOCKQUOTE> make free save against NULL pointers, </BLOCKQUOTE>
<A NAME="DOC.DOCU"></A>
<HR>
<H2>Documentation</H2>
<BLOCKQUOTE>
make free save against NULL pointers,
also the parameter ptr is set to NULL</BLOCKQUOTE>
<DL><DT><DD></DL><P><P><I><A HREF="index.html">Alphabetic index</A></I></P><HR>
<BR>
This page was generated with the help of <A HREF="http://docpp.sourceforge.net">DOC++</A>.
</BODY>
</HTML>

23
src/pbl/doc/PBL_LIST_.html
View file

@ -1,23 +0,0 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML>
<HEAD>
<TITLE>#define PBL_LIST_</TITLE>
<META NAME="GENERATOR" CONTENT="DOC++ 3.4.9">
</HEAD>
<center>
<H2>Program Base Library Functions</H2>
</center>
<H2>#define <A HREF="#DOC.DOCU">PBL_LIST_</A></H2><H2>( Parameters )</H2><BLOCKQUOTE> macros for linear list handling,</BLOCKQUOTE>
<A NAME="DOC.DOCU"></A>
<HR>
<H2>Documentation</H2>
<BLOCKQUOTE>
macros for linear list handling,</BLOCKQUOTE>
<DL><DT><DD></DL><P><P><I><A HREF="index.html">Alphabetic index</A></I></P><HR>
<BR>
This page was generated with the help of <A HREF="http://docpp.sourceforge.net">DOC++</A>.
</BODY>
</HTML>

23
src/pbl/doc/PBL_LIST_APPEND.html
View file

@ -1,23 +0,0 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML>
<HEAD>
<TITLE>#define PBL_LIST_APPEND</TITLE>
<META NAME="GENERATOR" CONTENT="DOC++ 3.4.9">
</HEAD>
<center>
<H2>Program Base Library Functions</H2>
</center>
<H2>#define <A HREF="#DOC.DOCU">PBL_LIST_APPEND</A></H2><H2>( HEAD, TAIL, ITEM, NEXT, PREV )</H2><BLOCKQUOTE> append an element to the end of a linear list</BLOCKQUOTE>
<A NAME="DOC.DOCU"></A>
<HR>
<H2>Documentation</H2>
<BLOCKQUOTE>
append an element to the end of a linear list</BLOCKQUOTE>
<DL><DT><DD></DL><P><P><I><A HREF="index.html">Alphabetic index</A></I></P><HR>
<BR>
This page was generated with the help of <A HREF="http://docpp.sourceforge.net">DOC++</A>.
</BODY>
</HTML>

23
src/pbl/doc/PBL_LIST_PUSH.html
View file

@ -1,23 +0,0 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML>
<HEAD>
<TITLE>#define PBL_LIST_PUSH</TITLE>
<META NAME="GENERATOR" CONTENT="DOC++ 3.4.9">
</HEAD>
<center>
<H2>Program Base Library Functions</H2>
</center>
<H2>#define <A HREF="#DOC.DOCU">PBL_LIST_PUSH</A></H2><H2>( HEAD, TAIL, ITEM, NEXT, PREV )</H2><BLOCKQUOTE> push an element to the beginning of a linear list</BLOCKQUOTE>
<A NAME="DOC.DOCU"></A>
<HR>
<H2>Documentation</H2>
<BLOCKQUOTE>
push an element to the beginning of a linear list</BLOCKQUOTE>
<DL><DT><DD></DL><P><P><I><A HREF="index.html">Alphabetic index</A></I></P><HR>
<BR>
This page was generated with the help of <A HREF="http://docpp.sourceforge.net">DOC++</A>.
</BODY>
</HTML>

23
src/pbl/doc/PBL_LIST_UNLINK.html
View file

@ -1,23 +0,0 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML>
<HEAD>
<TITLE>#define PBL_LIST_UNLINK</TITLE>
<META NAME="GENERATOR" CONTENT="DOC++ 3.4.9">
</HEAD>
<center>
<H2>Program Base Library Functions</H2>
</center>
<H2>#define <A HREF="#DOC.DOCU">PBL_LIST_UNLINK</A></H2><H2>( HEAD, TAIL, ITEM, NEXT, PREV )</H2><BLOCKQUOTE> remove an element from a linear list</BLOCKQUOTE>
<A NAME="DOC.DOCU"></A>
<HR>
<H2>Documentation</H2>
<BLOCKQUOTE>
remove an element from a linear list</BLOCKQUOTE>
<DL><DT><DD></DL><P><P><I><A HREF="index.html">Alphabetic index</A></I></P><HR>
<BR>
This page was generated with the help of <A HREF="http://docpp.sourceforge.net">DOC++</A>.
</BODY>
</HTML>

0
src/pbl/doc/gifs.db
View file

BIN
src/pbl/doc/icon1.gif
View file

Binary file not shown.
Side by side

Before

Width:  |  Height:  |  Size: 326 B

BIN
src/pbl/doc/icon2.gif
View file

Binary file not shown.
Side by side

Before

Width:  |  Height:  |  Size: 326 B

108
src/pbl/doc/index.html
View file

@ -1,108 +0,0 @@
<center>
<H1>Documentation for PBL</H1>
The Program Base Library
</center>
<H1>Table of Contents</H1>
<H2>General stuff</H2>
<UL>
<LI><A HREF="AIntroduction.html">A: Introduction</A>
<LI><A HREF="BFiles.html">B: Files</A>
<LI><A HREF="CErrorcodes.html">C: Error codes</A>
<LI><A HREF="DDefinitionsforKeyFileParameters.html">D: Definitions for Key File Parameters</A>
<LI><A HREF="EDefinitionsforISAMParameters.html">E: Definitions for ISAM Parameters</A>
</UL>
<H2>Functions</H2>
<UL>
<LI><A HREF="pblHtCreate.html">pblHtCreate</A> <I> create a new hash table</I>
<LI><A HREF="pblHtCurrent.html">pblHtCurrent</A> <I> get data of current key in hash table</I>
<LI><A HREF="pblHtDelete.html">pblHtDelete</A> <I> delete a hash table</I>
<LI><A HREF="pblHtFirst.html">pblHtFirst</A> <I> get data of first key in hash table</I>
<LI><A HREF="pblHtInsert.html">pblHtInsert</A> <I> insert a key / data pair into a hash table</I>
<LI><A HREF="pblHtLookup.html">pblHtLookup</A> <I> search for a key in a hash table</I>
<LI><A HREF="pblHtNext.html">pblHtNext</A> <I> get data of next key in hash table</I>
<LI><A HREF="pblHtRemove.html">pblHtRemove</A> <I> remove an item from the hash table</I>
<LI><A HREF="pblISAMFILE_TestFrame.html">pblISAMFILE_TestFrame</A> <I> test frame for the ISAM file library</I>
<LI><A HREF="pblIsamClose.html">pblIsamClose</A> <I> close an ISAM file</I>
<LI><A HREF="pblIsamCommit.html">pblIsamCommit</A> <I> commit or rollback changes done during a transaction</I>
<LI><A HREF="pblIsamDelete.html">pblIsamDelete</A> <I> delete the current record of the ISAM file.</I>
<LI><A HREF="pblIsamFind.html">pblIsamFind</A> <I> find a record in an ISAM file, set the current record</I>
<LI><A HREF="pblIsamFlush.html">pblIsamFlush</A> <I> flush an ISAM file</I>
<LI><A HREF="pblIsamGet.html">pblIsamGet</A> <I> get the key and keylen of a record</I>
<LI><A HREF="pblIsamInsert.html">pblIsamInsert</A> <I> insert a new record with the given keys and data into the isam file,</I>
<LI><A HREF="pblIsamOpen.html">pblIsamOpen</A> <I> open an ISAM file, creates the file if necessary</I>
<LI><A HREF="pblIsamReadData.html">pblIsamReadData</A> <I> read the data of the current record</I>
<LI><A HREF="pblIsamReadDatalen.html">pblIsamReadDatalen</A> <I> read the datalen of the current record</I>
<LI><A HREF="pblIsamReadKey.html">pblIsamReadKey</A> <I> read the key and keylen of the current record</I>
<LI><A HREF="pblIsamSetCompareFunction.html">pblIsamSetCompareFunction</A> <I> set an application specific compare function for a key of an ISAM file</I>
<LI><A HREF="pblIsamStartTransaction.html">pblIsamStartTransaction</A> <I> start a transaction on a set of ISAM files</I>
<LI><A HREF="pblIsamUpdateData.html">pblIsamUpdateData</A> <I> update the data of the current record</I>
<LI><A HREF="pblIsamUpdateKey.html">pblIsamUpdateKey</A> <I> update a key of the current record of the ISAM file</I>
<LI><A HREF="pblKEYFILE_TestFrame.html">pblKEYFILE_TestFrame</A> <I> test frame for the key file library</I>
<LI><A HREF="pblKfClose.html">pblKfClose</A> <I> close a key file</I>
<LI><A HREF="pblKfCommit.html">pblKfCommit</A> <I> commit or rollback changes done during a transaction.</I>
<LI><A HREF="pblKfCreate.html">pblKfCreate</A> <I> create a key file with the name specified by path.</I>
<LI><A HREF="pblKfDelete.html">pblKfDelete</A> <I> delete the current record of the key file.</I>
<LI><A HREF="pblKfFind.html">pblKfFind</A> <I> find a record in a key file, set the current record</I>
<LI><A HREF="pblKfFlush.html">pblKfFlush</A> <I> flush a key file</I>
<LI><A HREF="pblKfGetAbs.html">pblKfGetAbs</A> <I> set current record to a record with an absolute position index</I>
<LI><A HREF="pblKfGetRel.html">pblKfGetRel</A> <I> set current record to a record with a relative position index</I>
<LI><A HREF="pblKfInit.html">pblKfInit</A> <I> change the number of cache blocks used per open key file</I>
<LI><A HREF="pblKfInsert.html">pblKfInsert</A> <I> insert a new record with the given key and data into a key file,</I>
<LI><A HREF="pblKfOpen.html">pblKfOpen</A> <I> open an existing key file</I>
<LI><A HREF="pblKfRead.html">pblKfRead</A> <I> read the data of the current record of the file</I>
<LI><A HREF="pblKfRestorePosition.html">pblKfRestorePosition</A> <I> restore the position of the current record saved by the last previous call to <!1><A HREF="pblKfSavePosition.html">pblKfSavePosition</A>().</I>
<LI><A HREF="pblKfSavePosition.html">pblKfSavePosition</A> <I> save the position of the current record for later restore</I>
<LI><A HREF="pblKfSetCompareFunction.html">pblKfSetCompareFunction</A> <I> set an application specific compare function for the keys of a key file</I>
<LI><A HREF="pblKfStartTransaction.html">pblKfStartTransaction</A> <I> start a transaction on a key file</I>
<LI><A HREF="pblKfUpdate.html">pblKfUpdate</A> <I> update the data of the current record</I>
<LI><A HREF="pbl_BufToLong.html">pbl_BufToLong</A> <I> read a four byte long from a four byte buffer</I>
<LI><A HREF="pbl_BufToShort.html">pbl_BufToShort</A> <I> read a two byte short from a two byte buffer</I>
<LI><A HREF="pbl_LongSize.html">pbl_LongSize</A> <I> find out how many bytes a four byte long would use in a buffer</I>
<LI><A HREF="pbl_LongToBuf.html">pbl_LongToBuf</A> <I> copy a four byte long to a four byte buffer </I>
<LI><A HREF="pbl_LongToVarBuf.html">pbl_LongToVarBuf</A> <I> copy a four byte long to a variable length buffer</I>
<LI><A HREF="pbl_ShortToBuf.html">pbl_ShortToBuf</A> <I> copy a two byte short to a two byte buffer </I>
<LI><A HREF="pbl_VarBufSize.html">pbl_VarBufSize</A> <I> find out how many bytes a four byte long uses in a buffer</I>
<LI><A HREF="pbl_VarBufToLong.html">pbl_VarBufToLong</A> <I> read a four byte long from a variable length buffer</I>
<LI><A HREF="pbl_malloc.html">pbl_malloc</A> <I> replacement for malloc</I>
<LI><A HREF="pbl_malloc0.html">pbl_malloc0</A> <I> replacement for malloc, initializes the memory to 0</I>
<LI><A HREF="pbl_mem2dup.html">pbl_mem2dup</A> <I> duplicate and concatenate two memory buffers</I>
<LI><A HREF="pbl_memcmp.html">pbl_memcmp</A> <I> compare two memory buffers, similar to memcmp</I>
<LI><A HREF="pbl_memcmplen.html">pbl_memcmplen</A> <I> find out how many starting bytes of two buffers are equal</I>
<LI><A HREF="pbl_memdup.html">pbl_memdup</A> <I> duplicate a buffer, similar to strdup</I>
<LI><A HREF="pbl_memlcpy.html">pbl_memlcpy</A> <I> memcpy with target length check</I>
</UL>
<H2>Variables</H2>
<UL>
<LI><A HREF="pbl_errno.html">pbl_errno</A> <I> integer value used for returning error codes</I>
<LI><A HREF="pbl_errstr.html">pbl_errstr</A> <I> character buffer used for returning error strings</I>
</UL>
<H2>Macros</H2>
<UL>
<LI><A HREF="PBLDATALENGTH.html">PBLDATALENGTH</A> <I> maximum data length of data being stored on index blocks of key files, </I>
<LI><A HREF="PBLKEYLENGTH.html">PBLKEYLENGTH</A> <I> the maximum length of a key of the key file component, </I>
<LI><A HREF="PBL_FREE.html">PBL_FREE</A> <I> make free save against NULL pointers, </I>
<LI><A HREF="PBL_LIST_.html">PBL_LIST_</A> <I> macros for linear list handling,</I>
<LI><A HREF="PBL_LIST_APPEND.html">PBL_LIST_APPEND</A> <I> append an element to the end of a linear list</I>
<LI><A HREF="PBL_LIST_PUSH.html">PBL_LIST_PUSH</A> <I> push an element to the beginning of a linear list</I>
<LI><A HREF="PBL_LIST_UNLINK.html">PBL_LIST_UNLINK</A> <I> remove an element from a linear list</I>
<LI><A HREF="pblKfFirst.html">pblKfFirst</A> <I> set the current record to the first record of the file</I>
<LI><A HREF="pblKfLast.html">pblKfLast</A> <I> set the current record to the last record of the file</I>
<LI><A HREF="pblKfNext.html">pblKfNext</A> <I> set the current record to the next record of the file</I>
<LI><A HREF="pblKfPrev.html">pblKfPrev</A> <I> set the current record to the previous record of the file</I>
<LI><A HREF="pblKfThis.html">pblKfThis</A> <I> return the datalen of the current record</I>
</UL>
<H2>Typedefs</H2>
<UL>
<LI><A HREF="pblHashTable_t.html">pblHashTable_t</A> <I> the hash table type the pblHt* functions are dealing with, </I>
<LI><A HREF="pblIsamFile_t.html">pblIsamFile_t</A> <I> the ISAM file type the pblIsam* functions are dealing with, </I>
<LI><A HREF="pblKeyFile_t.html">pblKeyFile_t</A> <I> the key file type the pblKf* functions are dealing with, </I>
</UL>
<hr>
Copyright(C) 2002 Peter Graf, this software is distributed under the
<a href="http://www.gnu.org/">GNU</a> Lesser General Public License
<HR>
<BR>
This page was generated with the help of <A HREF="http://docpp.sourceforge.net">DOC++</A>.
</BODY>
</HTML>

24
src/pbl/doc/pblHashTable_t.html
View file

@ -1,24 +0,0 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML>
<HEAD>
<TITLE>typedef struct pblHashTable_s pblHashTable_t</TITLE>
<META NAME="GENERATOR" CONTENT="DOC++ 3.4.9">
</HEAD>
<center>
<H2>Program Base Library Functions</H2>
</center>
<H2>typedef struct pblHashTable_s <A HREF="#DOC.DOCU">pblHashTable_t</A></H2></H2><BLOCKQUOTE> the hash table type the pblHt* functions are dealing with, </BLOCKQUOTE>
<A NAME="DOC.DOCU"></A>
<HR>
<H2>Documentation</H2>
<BLOCKQUOTE>
the hash table type the pblHt* functions are dealing with,
the details of the structure are hidden from the user</BLOCKQUOTE>
<DL><DT><DD></DL><P><P><I><A HREF="index.html">Alphabetic index</A></I></P><HR>
<BR>
This page was generated with the help of <A HREF="http://docpp.sourceforge.net">DOC++</A>.
</BODY>
</HTML>

26
src/pbl/doc/pblHtCreate.html
View file

@ -1,26 +0,0 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML>
<HEAD>
<TITLE>pblHashTable_t* pblHtCreate</TITLE>
<META NAME="GENERATOR" CONTENT="DOC++ 3.4.9">
</HEAD>
<center>
<H2>Program Base Library Functions</H2>
</center>
<H2><!1><A HREF="pblHashTable_t.html">pblHashTable_t</A>* <A HREF="#DOC.DOCU">pblHtCreate</A></H2><H2>( void )</H2><BLOCKQUOTE> create a new hash table</BLOCKQUOTE>
<A NAME="DOC.DOCU"></A>
<HR>
<H2>Documentation</H2>
<BLOCKQUOTE>
create a new hash table
<P></BLOCKQUOTE>
<DL><DT><DT><B>Returns:</B><DD> pblHashTable_t * retptr != NULL: pointer to new hash table
<BR> pblHashTable_t * retptr == NULL: OUT OF MEMORY<BR><DD></DL><P><P><I><A HREF="index.html">Alphabetic index</A></I></P><HR>
<BR>
This page was generated with the help of <A HREF="http://docpp.sourceforge.net">DOC++</A>.
</BODY>
</HTML>

28
src/pbl/doc/pblHtCurrent.html
View file

@ -1,28 +0,0 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML>
<HEAD>
<TITLE>void* pblHtCurrent</TITLE>
<META NAME="GENERATOR" CONTENT="DOC++ 3.4.9">
</HEAD>
<center>
<H2>Program Base Library Functions</H2>
</center>
<H2>void* <A HREF="#DOC.DOCU">pblHtCurrent</A></H2><H2>( <!1><A HREF="pblHashTable_t.html">pblHashTable_t</A>* h )</H2><BLOCKQUOTE> get data of current key in hash table</BLOCKQUOTE>
<A NAME="DOC.DOCU"></A>
<HR>
<H2>Documentation</H2>
<BLOCKQUOTE>
get data of current key in hash table
<P></BLOCKQUOTE>
<DL><DT><DT><B>Parameters:</B><DD><B>h</B> - hash table to look in <BR><DT><B>Returns:</B><DD> void * retptr != NULL: pointer to data of current item
<BR> void * retptr == NULL: there is no current item in the hash table
<BR> PBL_ERROR_NOT_FOUND:
<BR><DD></DL><P><P><I><A HREF="index.html">Alphabetic index</A></I></P><HR>
<BR>
This page was generated with the help of <A HREF="http://docpp.sourceforge.net">DOC++</A>.
</BODY>
</HTML>

30
src/pbl/doc/pblHtDelete.html
View file

@ -1,30 +0,0 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML>
<HEAD>
<TITLE>int pblHtDelete</TITLE>
<META NAME="GENERATOR" CONTENT="DOC++ 3.4.9">
</HEAD>
<center>
<H2>Program Base Library Functions</H2>
</center>
<H2>int <A HREF="#DOC.DOCU">pblHtDelete</A></H2><H2>( <!1><A HREF="pblHashTable_t.html">pblHashTable_t</A>* h )</H2><BLOCKQUOTE> delete a hash table</BLOCKQUOTE>
<A NAME="DOC.DOCU"></A>
<HR>
<H2>Documentation</H2>
<BLOCKQUOTE>
delete a hash table
<P>the hash table has to be empty!
<P></BLOCKQUOTE>
<DL><DT><DT><B>Parameters:</B><DD><B>h</B> - hash table to delete <BR><DT><B>Returns:</B><DD> int ret == 0: ok
<BR> int ret == -1: an error, see pbl_errno:
<BR> PBL_ERROR_EXISTS: the hash table is not empty
<BR><DD></DL><P><P><I><A HREF="index.html">Alphabetic index</A></I></P><HR>
<BR>
This page was generated with the help of <A HREF="http://docpp.sourceforge.net">DOC++</A>.
</BODY>
</HTML>

40
src/pbl/doc/pblHtFirst.html
View file

@ -1,40 +0,0 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML>
<HEAD>
<TITLE>void* pblHtFirst</TITLE>
<META NAME="GENERATOR" CONTENT="DOC++ 3.4.9">
</HEAD>
<center>
<H2>Program Base Library Functions</H2>
</center>
<H2>void* <A HREF="#DOC.DOCU">pblHtFirst</A></H2><H2>( <!1><A HREF="pblHashTable_t.html">pblHashTable_t</A>* h )</H2><BLOCKQUOTE> get data of first key in hash table</BLOCKQUOTE>
<A NAME="DOC.DOCU"></A>
<HR>
<H2>Documentation</H2>
<BLOCKQUOTE>
get data of first key in hash table
<P>This call and <!1><A HREF="pblHtNext.html">pblHtNext</A> can be used in order to loop through all items
stored in a hash table.
<P><PRE>
Example:
<P> for( data = pblHtFirst( h ); data; data = pblHtNext( h ))
{
do something with the data pointer
}
</PRE>
<P></BLOCKQUOTE>
<DL><DT><DT><B>Parameters:</B><DD><B>h</B> - hash table to look in <BR><DT><B>Returns:</B><DD> void * retptr != NULL: pointer to data of first item
<BR> void * retptr == NULL: the hash table is empty
<BR> PBL_ERROR_NOT_FOUND:
<BR><DD></DL><P><P><I><A HREF="index.html">Alphabetic index</A></I></P><HR>
<BR>
This page was generated with the help of <A HREF="http://docpp.sourceforge.net">DOC++</A>.
</BODY>
</HTML>

35
src/pbl/doc/pblHtInsert.html
View file

@ -1,35 +0,0 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML>
<HEAD>
<TITLE>int pblHtInsert</TITLE>
<META NAME="GENERATOR" CONTENT="DOC++ 3.4.9">
</HEAD>
<center>
<H2>Program Base Library Functions</H2>
</center>
<H2>int <A HREF="#DOC.DOCU">pblHtInsert</A></H2><H2>( <!1><A HREF="pblHashTable_t.html">pblHashTable_t</A>* h, void* key, size_t keylen,<BR>&nbsp; void* dataptr )</H2><BLOCKQUOTE> insert a key / data pair into a hash table</BLOCKQUOTE>
<A NAME="DOC.DOCU"></A>
<HR>
<H2>Documentation</H2>
<BLOCKQUOTE>
insert a key / data pair into a hash table
<P>only the pointer to the data is stored in the hash table
no space is malloced for the data!
<P></BLOCKQUOTE>
<DL><DT><DT><B>Parameters:</B><DD><B>h</B> - hash table to insert to
<BR><B>key</B> - key to insert
<BR><B>keylen</B> - length of that key
<BR><B>dataptr</B> - dataptr to insert <BR><DT><B>Returns:</B><DD> int ret == 0: ok
<BR> int ret == -1: an error, see pbl_errno:
<BR> PBL_ERROR_EXISTS: an item with the same key already exists
<BR> PBL_ERROR_OUT_OF_MEMORY: out of memory
<BR><DD></DL><P><P><I><A HREF="index.html">Alphabetic index</A></I></P><HR>
<BR>
This page was generated with the help of <A HREF="http://docpp.sourceforge.net">DOC++</A>.
</BODY>
</HTML>

30
src/pbl/doc/pblHtLookup.html
View file

@ -1,30 +0,0 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML>
<HEAD>
<TITLE>void* pblHtLookup</TITLE>
<META NAME="GENERATOR" CONTENT="DOC++ 3.4.9">
</HEAD>
<center>
<H2>Program Base Library Functions</H2>
</center>
<H2>void* <A HREF="#DOC.DOCU">pblHtLookup</A></H2><H2>( <!1><A HREF="pblHashTable_t.html">pblHashTable_t</A>* h, void* key,<BR>&nbsp; size_t keylen )</H2><BLOCKQUOTE> search for a key in a hash table</BLOCKQUOTE>
<A NAME="DOC.DOCU"></A>
<HR>
<H2>Documentation</H2>
<BLOCKQUOTE>
search for a key in a hash table
<P></BLOCKQUOTE>
<DL><DT><DT><B>Parameters:</B><DD><B>h</B> - hash table to search in
<BR><B>key</B> - key to search
<BR><B>keylen</B> - length of that key <BR><DT><B>Returns:</B><DD> void * retptr != NULL: pointer to data of item found
<BR> void * retptr == NULL: no item found with the given key
<BR> PBL_ERROR_NOT_FOUND:
<BR><DD></DL><P><P><I><A HREF="index.html">Alphabetic index</A></I></P><HR>
<BR>
This page was generated with the help of <A HREF="http://docpp.sourceforge.net">DOC++</A>.
</BODY>
</HTML>

40
src/pbl/doc/pblHtNext.html
View file

@ -1,40 +0,0 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML>
<HEAD>
<TITLE>void* pblHtNext</TITLE>
<META NAME="GENERATOR" CONTENT="DOC++ 3.4.9">
</HEAD>
<center>
<H2>Program Base Library Functions</H2>
</center>
<H2>void* <A HREF="#DOC.DOCU">pblHtNext</A></H2><H2>( <!1><A HREF="pblHashTable_t.html">pblHashTable_t</A>* h )</H2><BLOCKQUOTE> get data of next key in hash table</BLOCKQUOTE>
<A NAME="DOC.DOCU"></A>
<HR>
<H2>Documentation</H2>
<BLOCKQUOTE>
get data of next key in hash table
<P>This call and <!1><A HREF="pblHtFirst.html">pblHtFirst</A> can be used in order to loop through all items
stored in a hash table.
<P><PRE>
Example:
<P> for( data = pblHtFirst( h ); data; data = pblHtNext( h ))
{
do something with the data pointer
}
</PRE>
<P></BLOCKQUOTE>
<DL><DT><DT><B>Parameters:</B><DD><B>h</B> - hash table to look in <BR><DT><B>Returns:</B><DD> void * retptr != NULL: pointer to data of next item
<BR> void * retptr == NULL: there is no next item in the hash table
<BR> PBL_ERROR_NOT_FOUND:
<BR><DD></DL><P><P><I><A HREF="index.html">Alphabetic index</A></I></P><HR>
<BR>
This page was generated with the help of <A HREF="http://docpp.sourceforge.net">DOC++</A>.
</BODY>
</HTML>

61
src/pbl/doc/pblHtRemove.html
View file

@ -1,61 +0,0 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML>
<HEAD>
<TITLE>int pblHtRemove</TITLE>
<META NAME="GENERATOR" CONTENT="DOC++ 3.4.9">
</HEAD>
<center>
<H2>Program Base Library Functions</H2>
</center>
<H2>int <A HREF="#DOC.DOCU">pblHtRemove</A></H2><H2>( <!1><A HREF="pblHashTable_t.html">pblHashTable_t</A>* h, void* key,<BR>&nbsp; size_t keylen )</H2><BLOCKQUOTE> remove an item from the hash table</BLOCKQUOTE>
<A NAME="DOC.DOCU"></A>
<HR>
<H2>Documentation</H2>
<BLOCKQUOTE>
remove an item from the hash table
<P>parameters key and keylen are optional, if they are not given
the current record is deleted
<P>if the current record is removed the pointer to the current record
is moved to the next record.
<P><PRE>
Example:
<P> for( data = pblHtFirst( h ); data; data = pblHtRemove( h, 0, 0 ))
{
this loop removes all items from a hash table
}
</PRE>
<P>if the current record is moved by this function the next call to
<!1><A HREF="pblHtNext.html">pblHtNext</A> will return the data of the then current record.
Therefore the following code does what is expected:
It visits all items of the hash table and removes the expired ones.
<P><PRE>
for( data = pblHtFirst( h ); data; data = pblHtNext( h ))
{
if( needs to be deleted( data ))
{
pblHtRemove( h, 0, 0 );
}
}
</PRE>
<P></BLOCKQUOTE>
<DL><DT><DT><B>Parameters:</B><DD><B>h</B> - hash table to remove from
<BR><B>key</B> - OPT: key to remove
<BR><B>keylen</B> - OPT: length of that key <BR><DT><B>Returns:</B><DD> int ret == 0: ok
<BR> int ret == -1: an error, see pbl_errno:
<BR> PBL_ERROR_NOT_FOUND: the current item is not positioned
<BR> or there is no item with the given key
<BR><DD></DL><P><P><I><A HREF="index.html">Alphabetic index</A></I></P><HR>
<BR>
This page was generated with the help of <A HREF="http://docpp.sourceforge.net">DOC++</A>.
</BODY>
</HTML>

74
src/pbl/doc/pblISAMFILE_TestFrame.html
View file

@ -1,74 +0,0 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML>
<HEAD>
<TITLE>int pblISAMFILE_TestFrame</TITLE>
<META NAME="GENERATOR" CONTENT="DOC++ 3.4.9">
</HEAD>
<center>
<H2>Program Base Library Functions</H2>
</center>
<H2>int <A HREF="#DOC.DOCU">pblISAMFILE_TestFrame</A></H2><H2>( int argc, char* argv[] )</H2><BLOCKQUOTE> test frame for the ISAM file library</BLOCKQUOTE>
<A NAME="DOC.DOCU"></A>
<HR>
<H2>Documentation</H2>
<BLOCKQUOTE>
test frame for the ISAM file library
<P>This test frame calls the PBL ISAM file library,
it is an interactive test frame capable of regression tests.
<P><B>Interactive mode:</B>
<UL>
Call the program pbliftst from a UNIX or DOS shell.
<BR>
The following commands to test the PBL ISAM File Library are supplied:
<UL>
<PRE>
q FOR QUIT
open filename keyfile1,dupfile2,... update
transaction < START | COMMIT | ROLLBACK >
close
flush
insert ,key1,key2... data
ninsert n key1,key2,... data
find index key < LT | LE | FI | EQ | LA | GE | GT >
nfind n index key < LT | LE | FI | EQ | LA | GE | GT >
get index < NEXT | PREV | FIRST | LAST | THIS >
datalen
readdata
readkey index
updatedata data
updatekey index key
ndelete n
</PRE>
</UL>
See <!1><A HREF="pblKEYFILE_TestFrame.html">pblKEYFILE_TestFrame</A> for an example to interactively use the
test frame.
</UL>
<B>Regression mode:</B>
<UL>
Five regression test cases are supplied with the PBL ISAM library.
<P>ISAM0001.TST, ISAM0002.TST, ISAM0003.TST, ISAM0004.TST and ISAM0005.TST.
<P>ISAM0001.TST and ISAM0004.TST are run when the "make test"
is done. Do the following if you want to run the test cases per hand
<PRE>
1. Build the pbliftst executable. make all
2. Create the sub directory isamtest. mkdir isamtest
3. Clear the sub directory isamtest. rm imamtest/0*
4. Run the test frame on this file. pbliftst ISAM0001.TST
5. Compare ISAM0001.TST and pbliftst.log diff ISAM0001.TST pbliftst.log
</PRE>
There should be no differences reported, if so your build of the
PBL library is most likely ok!
<P></UL></BLOCKQUOTE>
<DL><DT><DD></DL><P><P><I><A HREF="index.html">Alphabetic index</A></I></P><HR>
<BR>
This page was generated with the help of <A HREF="http://docpp.sourceforge.net">DOC++</A>.
</BODY>
</HTML>

30
src/pbl/doc/pblIsamClose.html
View file

@ -1,30 +0,0 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML>
<HEAD>
<TITLE>int pblIsamClose</TITLE>
<META NAME="GENERATOR" CONTENT="DOC++ 3.4.9">
</HEAD>
<center>
<H2>Program Base Library Functions</H2>
</center>
<H2>int <A HREF="#DOC.DOCU">pblIsamClose</A></H2><H2>( <!1><A HREF="pblIsamFile_t.html">pblIsamFile_t</A>* isamfile )</H2><BLOCKQUOTE> close an ISAM file</BLOCKQUOTE>
<A NAME="DOC.DOCU"></A>
<HR>
<H2>Documentation</H2>
<BLOCKQUOTE>
close an ISAM file
<P>all changes are flushed to disk before,
all memory allocated for the file is released.
<P></BLOCKQUOTE>
<DL><DT><DT><B>Parameters:</B><DD><B>isamfile</B> - ISAM file to close <BR><DT><B>Returns:</B><DD> int rc == 0: call went ok, file is closed
<BR> int rc != 0: some error, see pbl_errno
<BR><DD></DL><P><P><I><A HREF="index.html">Alphabetic index</A></I></P><HR>
<BR>
This page was generated with the help of <A HREF="http://docpp.sourceforge.net">DOC++</A>.
</BODY>
</HTML>

40
src/pbl/doc/pblIsamCommit.html
View file

@ -1,40 +0,0 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML>
<HEAD>
<TITLE>int pblIsamCommit</TITLE>
<META NAME="GENERATOR" CONTENT="DOC++ 3.4.9">
</HEAD>
<center>
<H2>Program Base Library Functions</H2>
</center>
<H2>int <A HREF="#DOC.DOCU">pblIsamCommit</A></H2><H2>( int nfiles, <!1><A HREF="pblIsamFile_t.html">pblIsamFile_t</A>** isamfiles,<BR>&nbsp; int rollback )</H2><BLOCKQUOTE> commit or rollback changes done during a transaction</BLOCKQUOTE>
<A NAME="DOC.DOCU"></A>
<HR>
<H2>Documentation</H2>
<BLOCKQUOTE>
commit or rollback changes done during a transaction
<P>transactions can be nested, if so the commit
only happens when the outermost transaction
calls a commit.
<P>the commit only happens to process space buffer cache,
call <!1><A HREF="pblIsamFlush.html">pblIsamFlush</A>() after <!1><A HREF="pblIsamCommit.html">pblIsamCommit</A>() if you want to
flush to kernel space buffer cache.
<P></BLOCKQUOTE>
<DL><DT><DT><B>Parameters:</B><DD><B>nfiles</B> - number of files in ISAM file list
<BR><B>isamfiles</B> - ISAM file list to commit changes of
<BR><B>rollback</B> - != 0: roll back the changes, == 0: commit the changes <BR><DT><B>Returns:</B><DD> int rc == 0: the commit went ok
<BR> int rc > 0: a rollback happened, either because the caller
requested it or because an inner transaction resulted
in a rollback
<BR> int rc < 0: some error, see pbl_errno
<BR><DD></DL><P><P><I><A HREF="index.html">Alphabetic index</A></I></P><HR>
<BR>
This page was generated with the help of <A HREF="http://docpp.sourceforge.net">DOC++</A>.
</BODY>
</HTML>

37
src/pbl/doc/pblIsamDelete.html
View file

@ -1,37 +0,0 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML>
<HEAD>
<TITLE>int pblIsamDelete</TITLE>
<META NAME="GENERATOR" CONTENT="DOC++ 3.4.9">
</HEAD>
<center>
<H2>Program Base Library Functions</H2>
</center>
<H2>int <A HREF="#DOC.DOCU">pblIsamDelete</A></H2><H2>( <!1><A HREF="pblIsamFile_t.html">pblIsamFile_t</A>* isamfile )</H2><BLOCKQUOTE> delete the current record of the ISAM file.</BLOCKQUOTE>
<A NAME="DOC.DOCU"></A>
<HR>
<H2>Documentation</H2>
<BLOCKQUOTE>
delete the current record of the ISAM file.
<P>the current record of the file is set to the next record or
if the last record is deleted, to the previous record,
<P>if there are no more records in the file after the delete
the current record is of course unpositioned
<P><P>
<B>RESTRICTIONS</B>:
<BR> - the file must be open for update,
<P></BLOCKQUOTE>
<DL><DT><DT><B>Parameters:</B><DD><B>isamfile</B> - ISAM file to delete from <BR><DT><B>Returns:</B><DD> int rc == 0: call went ok
<BR> int rc != 0: some error occured, see pbl_errno
<BR><DD></DL><P><P><I><A HREF="index.html">Alphabetic index</A></I></P><HR>
<BR>
This page was generated with the help of <A HREF="http://docpp.sourceforge.net">DOC++</A>.
</BODY>
</HTML>

24
src/pbl/doc/pblIsamFile_t.html
View file

@ -1,24 +0,0 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML>
<HEAD>
<TITLE>typedef struct pblIsamFile_s pblIsamFile_t</TITLE>
<META NAME="GENERATOR" CONTENT="DOC++ 3.4.9">
</HEAD>
<center>
<H2>Program Base Library Functions</H2>
</center>
<H2>typedef struct pblIsamFile_s <A HREF="#DOC.DOCU">pblIsamFile_t</A></H2></H2><BLOCKQUOTE> the ISAM file type the pblIsam* functions are dealing with, </BLOCKQUOTE>
<A NAME="DOC.DOCU"></A>
<HR>
<H2>Documentation</H2>
<BLOCKQUOTE>
the ISAM file type the pblIsam* functions are dealing with,
the details of the structure are hidden from the user</BLOCKQUOTE>
<DL><DT><DD></DL><P><P><I><A HREF="index.html">Alphabetic index</A></I></P><HR>
<BR>
This page was generated with the help of <A HREF="http://docpp.sourceforge.net">DOC++</A>.
</BODY>
</HTML>

66
src/pbl/doc/pblIsamFind.html
View file

@ -1,66 +0,0 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML>
<HEAD>
<TITLE>int pblIsamFind</TITLE>
<META NAME="GENERATOR" CONTENT="DOC++ 3.4.9">
</HEAD>
<center>
<H2>Program Base Library Functions</H2>
</center>
<H2>int <A HREF="#DOC.DOCU">pblIsamFind</A></H2><H2>( <!1><A HREF="pblIsamFile_t.html">pblIsamFile_t</A>* isamfile, int which,<BR>&nbsp; int index, unsigned char* skey, int skeylen,<BR>&nbsp; unsigned char* okey )</H2><BLOCKQUOTE> find a record in an ISAM file, set the current record</BLOCKQUOTE>
<A NAME="DOC.DOCU"></A>
<HR>
<H2>Documentation</H2>
<BLOCKQUOTE>
find a record in an ISAM file, set the current record
<P>parameter which specifies which record to find relative
to the search key specified by skey and skeylen.
the following values for which are possible
<P><BR><B> PBLEQ </B> - find a record whose key is equal to skey
<BR><B> PBLFI </B> - find the first record that is equal
<BR><B> PBLLA </B> - find the last record that is equal
<BR><B> PBLGE </B> - find the last record that is equal or the smallest
record that is greater
<BR><B> PBLGT </B> - find the smallest record that is greater
<BR><B> PBLLE </B> - find the first record that is equal or the biggest
record that is smaller
<BR><B> PBLLT </B> - find the biggest record that is smaller
<P>parameter index specifies which of the keys to use
<P><P>
<B>RESTRICTIONS</B>:
<BR> - the out parameter okey must point to a memory area that is
big enough to hold any possible key, i.e 255 bytes
<P></BLOCKQUOTE>
<DL><DT><DT><B>Parameters:</B><DD><B>isamfile</B> - ISAM file to search in
<BR><B>which</B> - mode to use for search
<BR><B>index</B> - index of key to use for search
<BR><B>skey</B> - key to use for search
<BR><B>skeylen</B> - length of search key
<BR><B>okey</B> - buffer for result key <BR><DT><B>Returns:</B><DD> int rc >= 0:
<UL>
<LI> call went ok,
the value returned is the length
of the key of the record found,
<LI> the key of the record is copied to okey,
<LI> the current record of the file is set to the
record found
</UL>
<BR> int rc < 0:
<UL>
<LI> some error occured, see pbl_errno
especially PBL_ERROR_NOT_FOUND, if there is no
matching record
</UL>
<BR><DD></DL><P><P><I><A HREF="index.html">Alphabetic index</A></I></P><HR>
<BR>
This page was generated with the help of <A HREF="http://docpp.sourceforge.net">DOC++</A>.
</BODY>
</HTML>

29
src/pbl/doc/pblIsamFlush.html
View file

@ -1,29 +0,0 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML>
<HEAD>
<TITLE>int pblIsamFlush</TITLE>
<META NAME="GENERATOR" CONTENT="DOC++ 3.4.9">
</HEAD>
<center>
<H2>Program Base Library Functions</H2>
</center>
<H2>int <A HREF="#DOC.DOCU">pblIsamFlush</A></H2><H2>( <!1><A HREF="pblIsamFile_t.html">pblIsamFile_t</A>* isamfile )</H2><BLOCKQUOTE> flush an ISAM file</BLOCKQUOTE>
<A NAME="DOC.DOCU"></A>
<HR>
<H2>Documentation</H2>
<BLOCKQUOTE>
flush an ISAM file
<P>all changes are flushed to disk,
<P></BLOCKQUOTE>
<DL><DT><DT><B>Parameters:</B><DD><B>isamfile</B> - ISAM file to flush <BR><DT><B>Returns:</B><DD> int rc == 0: call went ok
<BR> int rc != 0: some error, see pbl_errno
<BR><DD></DL><P><P><I><A HREF="index.html">Alphabetic index</A></I></P><HR>
<BR>
This page was generated with the help of <A HREF="http://docpp.sourceforge.net">DOC++</A>.
</BODY>
</HTML>

62
src/pbl/doc/pblIsamGet.html
View file

@ -1,62 +0,0 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML>
<HEAD>
<TITLE>int pblIsamGet</TITLE>
<META NAME="GENERATOR" CONTENT="DOC++ 3.4.9">
</HEAD>
<center>
<H2>Program Base Library Functions</H2>
</center>
<H2>int <A HREF="#DOC.DOCU">pblIsamGet</A></H2><H2>( <!1><A HREF="pblIsamFile_t.html">pblIsamFile_t</A>* isamfile, int which, int index,<BR>&nbsp; unsigned char* okey )</H2><BLOCKQUOTE> get the key and keylen of a record</BLOCKQUOTE>
<A NAME="DOC.DOCU"></A>
<HR>
<H2>Documentation</H2>
<BLOCKQUOTE>
get the key and keylen of a record
<P>parameter which specifies which record to get relative
to the search key specified by index.
the following values for which are possible
<P><BR><B> PBLTHIS </B> - get key and keylen of current record
<BR><B> PBLNEXT </B> - get key and keylen of next record
<BR><B> PBLPREV </B> - get key and keylen of previous record
<BR><B> PBLFIRST </B> - get key and keylen of first record
<BR><B> PBLLAST </B> - get key and keylen of last record
<P>parameter index specifies which of the keys to get,
the pseudo index value -1 can be used in order to access the file
sequentially in the order the records were inserted.
okey is not set in this case, a keylength of 0 is returned in case
the call went ok.
<P><P>
<B>RESTRICTIONS</B>:
<BR> - the out parameter okey must point to a memory area that is
big enough to hold any possible key, i.e 255 bytes
<P></BLOCKQUOTE>
<DL><DT><DT><B>Parameters:</B><DD><B>isamfile</B> - ISAM file to read in
<BR><B>which</B> - mode to use for read
<BR><B>index</B> - index of key to use for read
<BR><B>okey</B> - buffer for result key <BR><DT><B>Returns:</B><DD> int rc >= 0:
<UL>
<LI> call went ok,
the value returned is the length
of the key of the record found,
<LI> the key of the record is copied to okey,
<LI> the current record of the file is set to the
record found
</UL>
<BR> int rc < 0:
<UL>
<LI> some error occured, see pbl_errno
</UL>
<BR><DD></DL><P><P><I><A HREF="index.html">Alphabetic index</A></I></P><HR>
<BR>
This page was generated with the help of <A HREF="http://docpp.sourceforge.net">DOC++</A>.
</BODY>
</HTML>

52
src/pbl/doc/pblIsamInsert.html
View file

@ -1,52 +0,0 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML>
<HEAD>
<TITLE>int pblIsamInsert</TITLE>
<META NAME="GENERATOR" CONTENT="DOC++ 3.4.9">
</HEAD>
<center>
<H2>Program Base Library Functions</H2>
</center>
<H2>int <A HREF="#DOC.DOCU">pblIsamInsert</A></H2><H2>( <!1><A HREF="pblIsamFile_t.html">pblIsamFile_t</A>* isamfile,<BR>&nbsp; unsigned char* allkeys, int allkeyslen,<BR>&nbsp; unsigned char* data, long datalen )</H2><BLOCKQUOTE> insert a new record with the given keys and data into the isam file,</BLOCKQUOTE>
<A NAME="DOC.DOCU"></A>
<HR>
<H2>Documentation</H2>
<BLOCKQUOTE>
insert a new record with the given keys and data into the isam file,
<P>the current record of the file will be set to the new record
<P><P>
<B>RESTRICTIONS</B>:
<BR> - the file must be open for update,
<BR> - allkeys must point to the keys to be inserted,
<BR> - allkeyslen must be bigger than 0 and smaller than 1024,
<BR> - data must point to the data be inserted,
<BR> - datalen must not be negative,
<BR> - if datalen == 0, the pointer data is not evaluated at all
<P>Parameter <I>allkeys</I> must contain all values for all keys
of the record. The values have to be prepended by one byte giving
the length of the following value. All values have to be concatenated
into one string.
<P>Example:
<PRE> 4isam4file3key </PRE>
with the numbers as binary values and the letters ascii,
specifies three keys with the values "isam", "file" and "key".
<P></BLOCKQUOTE>
<DL><DT><DT><B>Parameters:</B><DD><B>isamfile</B> - ISAM file to insert to
<BR><B>allkeys</B> - pointers to all keys to insert
<BR><B>allkeyslen</B> - total length of all keys to insert
<BR><B>data</B> - data to insert
<BR><B>datalen</B> - length of the data <BR><DT><B>Returns:</B><DD> int rc == 0: call went ok
<BR> int rc != 0: some error occured, see pbl_errno
<BR><DD></DL><P><P><I><A HREF="index.html">Alphabetic index</A></I></P><HR>
<BR>
This page was generated with the help of <A HREF="http://docpp.sourceforge.net">DOC++</A>.
</BODY>
</HTML>

40
src/pbl/doc/pblIsamOpen.html
View file

@ -1,40 +0,0 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML>
<HEAD>
<TITLE>pblIsamFile_t* pblIsamOpen</TITLE>
<META NAME="GENERATOR" CONTENT="DOC++ 3.4.9">
</HEAD>
<center>
<H2>Program Base Library Functions</H2>
</center>
<H2><!1><A HREF="pblIsamFile_t.html">pblIsamFile_t</A>* <A HREF="#DOC.DOCU">pblIsamOpen</A></H2><H2>( char* path,<BR>&nbsp; int update,<BR>&nbsp; void* filesettag,<BR>&nbsp; int nkeys,<BR>&nbsp; char** keyfilenames,<BR>&nbsp; int* keydup )</H2><BLOCKQUOTE> open an ISAM file, creates the file if necessary</BLOCKQUOTE>
<A NAME="DOC.DOCU"></A>
<HR>
<H2>Documentation</H2>
<BLOCKQUOTE>
open an ISAM file, creates the file if necessary
<P>if update is 0, the ISAM file is opened for read access only,
if update is not 0 the ISAM file is opened for reading and writing
<P>a file set tag can be attached to the ISAM file,
if a file having a non NULL file set tag is flushed
to disk all files having the same file set tag attached
are flushed as well.
<P></BLOCKQUOTE>
<DL><DT><DT><B>Parameters:</B><DD><B>path</B> - path of file to create
<BR><B>update</B> - flag: should file be opened for update?
<BR><B>filesettag</B> - filesettag, for flushing multiple files consistently
<BR><B>nkeys</B> - number of key files to create
<BR><B>keyfilenames</B> - list of names of key index files to create
<BR><B>keydup</B> - flaglist: is the i'th index key a duplicate key? <BR><DT><B>Returns:</B><DD> pblIsamFile_t * retptr == NULL: an error occured, see pbl_errno
<BR> pblIsamFile_t * retptr != NULL: a pointer to an ISAM file descriptor
<BR><DD></DL><P><P><I><A HREF="index.html">Alphabetic index</A></I></P><HR>
<BR>
This page was generated with the help of <A HREF="http://docpp.sourceforge.net">DOC++</A>.
</BODY>
</HTML>

32
src/pbl/doc/pblIsamReadData.html
View file

@ -1,32 +0,0 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML>
<HEAD>
<TITLE>long pblIsamReadData</TITLE>
<META NAME="GENERATOR" CONTENT="DOC++ 3.4.9">
</HEAD>
<center>
<H2>Program Base Library Functions</H2>
</center>
<H2>long <A HREF="#DOC.DOCU">pblIsamReadData</A></H2><H2>( <!1><A HREF="pblIsamFile_t.html">pblIsamFile_t</A>* isamfile,<BR>&nbsp; unsigned char* buffer,<BR>&nbsp; long bufferlen )</H2><BLOCKQUOTE> read the data of the current record</BLOCKQUOTE>
<A NAME="DOC.DOCU"></A>
<HR>
<H2>Documentation</H2>
<BLOCKQUOTE>
read the data of the current record
<P>parameter bufferlen specifies how many bytes to read
<P></BLOCKQUOTE>
<DL><DT><DT><B>Parameters:</B><DD><B>isamfile</B> - ISAM file to read from
<BR><B>buffer</B> - buffer to read to
<BR><B>bufferlen</B> - length of that buffer <BR><DT><B>Returns:</B><DD> long rc >= 0: call went ok, the value returned is the length
of the data copied
<BR> long rc < 0: some error occured, see pbl_errno
<BR><DD></DL><P><P><I><A HREF="index.html">Alphabetic index</A></I></P><HR>
<BR>
This page was generated with the help of <A HREF="http://docpp.sourceforge.net">DOC++</A>.
</BODY>
</HTML>

28
src/pbl/doc/pblIsamReadDatalen.html
View file

@ -1,28 +0,0 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML>
<HEAD>
<TITLE>long pblIsamReadDatalen</TITLE>
<META NAME="GENERATOR" CONTENT="DOC++ 3.4.9">
</HEAD>
<center>
<H2>Program Base Library Functions</H2>
</center>
<H2>long <A HREF="#DOC.DOCU">pblIsamReadDatalen</A></H2><H2>( <!1><A HREF="pblIsamFile_t.html">pblIsamFile_t</A>* isamfile )</H2><BLOCKQUOTE> read the datalen of the current record</BLOCKQUOTE>
<A NAME="DOC.DOCU"></A>
<HR>
<H2>Documentation</H2>
<BLOCKQUOTE>
read the datalen of the current record
<P></BLOCKQUOTE>
<DL><DT><DT><B>Parameters:</B><DD><B>isamfile</B> - ISAM file to read length of data from <BR><DT><B>Returns:</B><DD> long rc >= 0: call went ok, the value returned is the length
of the data of the record,
<BR> long rc < 0: some error occured, see pbl_errno
<BR><DD></DL><P><P><I><A HREF="index.html">Alphabetic index</A></I></P><HR>
<BR>
This page was generated with the help of <A HREF="http://docpp.sourceforge.net">DOC++</A>.
</BODY>
</HTML>

46
src/pbl/doc/pblIsamReadKey.html
View file

@ -1,46 +0,0 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML>
<HEAD>
<TITLE>int pblIsamReadKey</TITLE>
<META NAME="GENERATOR" CONTENT="DOC++ 3.4.9">
</HEAD>
<center>
<H2>Program Base Library Functions</H2>
</center>
<H2>int <A HREF="#DOC.DOCU">pblIsamReadKey</A></H2><H2>( <!1><A HREF="pblIsamFile_t.html">pblIsamFile_t</A>* isamfile, int index,<BR>&nbsp; unsigned char* okey )</H2><BLOCKQUOTE> read the key and keylen of the current record</BLOCKQUOTE>
<A NAME="DOC.DOCU"></A>
<HR>
<H2>Documentation</H2>
<BLOCKQUOTE>
read the key and keylen of the current record
<P>parameter index specifies which of the keys to read
<P><P>
<B>RESTRICTIONS</B>:
<BR> - the out parameter okey must point to a memory area that is
big enough to hold any possible key, i.e 255 bytes
<P></BLOCKQUOTE>
<DL><DT><DT><B>Parameters:</B><DD><B>isamfile</B> - ISAM file to read in
<BR><B>index</B> - index of key read
<BR><B>okey</B> - buffer for result key <BR><DT><B>Returns:</B><DD> int rc >= 0:
<UL>
<LI> call went ok,
the value returned is the length of the key
<LI> the key of the record is copied to okey,
<LI> the current record of the file is not affected
by this function
</UL>
<BR> int rc < 0:
<UL>
<LI> some error occured, see pbl_errno
</UL>
<BR><DD></DL><P><P><I><A HREF="index.html">Alphabetic index</A></I></P><HR>
<BR>
This page was generated with the help of <A HREF="http://docpp.sourceforge.net">DOC++</A>.
</BODY>
</HTML>

43
src/pbl/doc/pblIsamSetCompareFunction.html
View file

@ -1,43 +0,0 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML>
<HEAD>
<TITLE>int pblIsamSetCompareFunction</TITLE>
<META NAME="GENERATOR" CONTENT="DOC++ 3.4.9">
</HEAD>
<center>
<H2>Program Base Library Functions</H2>
</center>
<H2>int <A HREF="#DOC.DOCU">pblIsamSetCompareFunction</A></H2><H2>( <!1><A HREF="pblIsamFile_t.html">pblIsamFile_t</A>* isamfile,<BR>&nbsp; int index,<BR>&nbsp; int (* keycompare ) ( void* left,<BR>&nbsp; size_t llen, void* right,<BR>&nbsp; size_t rlen ) )</H2><BLOCKQUOTE> set an application specific compare function for a key of an ISAM file</BLOCKQUOTE>
<A NAME="DOC.DOCU"></A>
<HR>
<H2>Documentation</H2>
<BLOCKQUOTE>
set an application specific compare function for a key of an ISAM file
<P>parameter index specifies which of the indices to set
the compare function for
<P>an application specific compare function can be used in order to
implement special orderings of the values of an index, e.g.
because of the use of european "umlauts" in names
<P>the default compare function is the c-library memcmp function
the keycompare function should behave like memcmp
<P></BLOCKQUOTE>
<DL><DT><DT><B>Parameters:</B><DD><B>isamfile</B> - ISAM file to set function for
<BR><B>index</B> - index of key to set function for
<BR><B>keycompare</B> - compare function to set
<BR><B>left</B> - "left" buffer for compare
<BR><B>llen</B> - length of that buffer
<BR><B>right</B> - "right" buffer for compare
<BR><B>rlen</B> - length of that buffer <BR><DT><B>Returns:</B><DD> int rc == 0: call went ok
<BR> int rc != 0: some error occured, see pbl_errno
<BR><DD></DL><P><P><I><A HREF="index.html">Alphabetic index</A></I></P><HR>
<BR>
This page was generated with the help of <A HREF="http://docpp.sourceforge.net">DOC++</A>.
</BODY>
</HTML>

32
src/pbl/doc/pblIsamStartTransaction.html
View file

@ -1,32 +0,0 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML>
<HEAD>
<TITLE>int pblIsamStartTransaction</TITLE>
<META NAME="GENERATOR" CONTENT="DOC++ 3.4.9">
</HEAD>
<center>
<H2>Program Base Library Functions</H2>
</center>
<H2>int <A HREF="#DOC.DOCU">pblIsamStartTransaction</A></H2><H2>( int nfiles,<BR>&nbsp; <!1><A HREF="pblIsamFile_t.html">pblIsamFile_t</A>** isamfiles )</H2><BLOCKQUOTE> start a transaction on a set of ISAM files</BLOCKQUOTE>
<A NAME="DOC.DOCU"></A>
<HR>
<H2>Documentation</H2>
<BLOCKQUOTE>
start a transaction on a set of ISAM files
<P>transactions can be nested
<P></BLOCKQUOTE>
<DL><DT><DT><B>Parameters:</B><DD><B>nfiles</B> - number of files in ISAM file list
<BR><B>isamfiles</B> - ISAM file list to start transaction on <BR><DT><B>Returns:</B><DD> int rc == 0: the transaction was started successfully
<BR> int rc > 0: the transaction was started
but another transaction has resulted in
a rollback request on the file already
<BR><DD></DL><P><P><I><A HREF="index.html">Alphabetic index</A></I></P><HR>
<BR>
This page was generated with the help of <A HREF="http://docpp.sourceforge.net">DOC++</A>.
</BODY>
</HTML>

34
src/pbl/doc/pblIsamUpdateData.html
View file

@ -1,34 +0,0 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML>
<HEAD>
<TITLE>long pblIsamUpdateData</TITLE>
<META NAME="GENERATOR" CONTENT="DOC++ 3.4.9">
</HEAD>
<center>
<H2>Program Base Library Functions</H2>
</center>
<H2>long <A HREF="#DOC.DOCU">pblIsamUpdateData</A></H2><H2>( <!1><A HREF="pblIsamFile_t.html">pblIsamFile_t</A>* isamfile,<BR>&nbsp; unsigned char* data, long datalen )</H2><BLOCKQUOTE> update the data of the current record</BLOCKQUOTE>
<A NAME="DOC.DOCU"></A>
<HR>
<H2>Documentation</H2>
<BLOCKQUOTE>
update the data of the current record
<P>parameter datalen specifies how many bytes to write
<P>the file must be open for update
<P></BLOCKQUOTE>
<DL><DT><DT><B>Parameters:</B><DD><B>isamfile</B> - ISAM file to update
<BR><B>data</B> - data to write
<BR><B>datalen</B> - length of that data <BR><DT><B>Returns:</B><DD> long rc >= 0: call went ok, the value returned is the length
of the data copied
<BR> long rc < 0: some error occured, see pbl_errno
<BR><DD></DL><P><P><I><A HREF="index.html">Alphabetic index</A></I></P><HR>
<BR>
This page was generated with the help of <A HREF="http://docpp.sourceforge.net">DOC++</A>.
</BODY>
</HTML>

34
src/pbl/doc/pblIsamUpdateKey.html
View file

@ -1,34 +0,0 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML>
<HEAD>
<TITLE>int pblIsamUpdateKey</TITLE>
<META NAME="GENERATOR" CONTENT="DOC++ 3.4.9">
</HEAD>
<center>
<H2>Program Base Library Functions</H2>
</center>
<H2>int <A HREF="#DOC.DOCU">pblIsamUpdateKey</A></H2><H2>( <!1><A HREF="pblIsamFile_t.html">pblIsamFile_t</A>* isamfile, int index,<BR>&nbsp; unsigned char* ukey, int ukeylen )</H2><BLOCKQUOTE> update a key of the current record of the ISAM file</BLOCKQUOTE>
<A NAME="DOC.DOCU"></A>
<HR>
<H2>Documentation</H2>
<BLOCKQUOTE>
update a key of the current record of the ISAM file
<P>parameter index specifies which of the keys to update
<P>the file must be open for update
<P></BLOCKQUOTE>
<DL><DT><DT><B>Parameters:</B><DD><B>isamfile</B> - ISAM file to update key for
<BR><B>index</B> - index of key to update
<BR><B>ukey</B> - new value for the key to update
<BR><B>ukeylen</B> - length of that value <BR><DT><B>Returns:</B><DD> int rc == 0: call went ok
<BR> int rc != 0: some error occured, see pbl_errno
<BR><DD></DL><P><P><I><A HREF="index.html">Alphabetic index</A></I></P><HR>
<BR>
This page was generated with the help of <A HREF="http://docpp.sourceforge.net">DOC++</A>.
</BODY>
</HTML>

142
src/pbl/doc/pblKEYFILE_TestFrame.html
View file

@ -1,142 +0,0 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML>
<HEAD>
<TITLE>int pblKEYFILE_TestFrame</TITLE>
<META NAME="GENERATOR" CONTENT="DOC++ 3.4.9">
</HEAD>
<center>
<H2>Program Base Library Functions</H2>
</center>
<H2>int <A HREF="#DOC.DOCU">pblKEYFILE_TestFrame</A></H2><H2>( int argc, char* argv[] )</H2><BLOCKQUOTE> test frame for the key file library</BLOCKQUOTE>
<A NAME="DOC.DOCU"></A>
<HR>
<H2>Documentation</H2>
<BLOCKQUOTE>
test frame for the key file library
<P>This test frame calls the key file library,
it is an interactive test frame capable of regression tests.
<P><B>Interactive mode:</B>
<UL>
Call the program pblkftst from a UNIX or DOS shell.
<BR>
The following commands to test the PBL Key File Library are supplied:
<UL>
<PRE>
q FOR QUIT
create <filename>
open <filename> <update>
close | flush | delete
insert <key> <data>
ninsert <n> <key> <data>
find <key> < LT | LE | FI | EQ | LA | GE | GT >
update <data>
ndelete <n>
first | last | next | prev | this | read
list <n>
</PRE>
</UL>
</UL>
<B>Interactive mode example:</B>
<UL>
The following short examples demonstrates how to use the interactive
test frame. Lines starting with a # are printed by the program
lines starting with other characters are user input.
<UL>
<PRE>
pblkftst
<P>##command:
create /tmp/keytest
# create filename
# pblKfCreate( /tmp/keytest )
# ok!
<P>##command:
insert testkey testdata
# insert key, data
# pblKfInsert( 1, testkey, 8, testdata, 9 )
# rc 0, pbl_errno 0, errno 0
<P>##command:
first
# pblKfFirst( 1 )
# datalen 9, key testkey, keylen 8
<P>##command:
close
# pblKfClose( 1 )
# rc 0, pbl_errno 0, errno 0
<P>##command:
quit
</PRE>
</UL>
</UL>
<P><B>Regression mode:</B>
<UL>
Put a sequence of test commands into a test batch file.
<P>
Example:
<UL>
Open a new file KEY0001.TST and add the following lines
<PRE>
create /tmp/keytest2
insert testkey testdata
first
close
quit
</PRE>
</UL>
Then run pblkftst KEY0001.TST
<P>The program creates a log file called <B>pblkftst.log</B> when run.
This log file can be used as regression input file for further
tests.
<UL>
<PRE>
##command:
create # create filename
/tmp/key0001
# pblKfCreate( /tmp/key0001 )
# ok!
<P>##command:
insert # insert key, data
testkey testdata
# pblKfInsert( 1, testkey, 8, testdata, 9 )
# rc 0, pbl_errno 0, errno 0
<P>##command:
first
# pblKfFirst( 1 )
# datalen 9, key testkey, keylen 8
<P>##command:
close
# pblKfClose( 1 )
# rc 0, pbl_errno 0, errno 0
<P>##command:
quit
</PRE>
</UL>
Keep the contents of this file and diff it with the outout of
the KEY0001.TST testcase you created whenever you change
the code of the library.
<P>See <!1><A HREF="pblISAMFILE_TestFrame.html">pblISAMFILE_TestFrame</A> for an example of regression
tests with a test frame. The regression test cases given with
<!1><A HREF="pblISAMFILE_TestFrame.html">pblISAMFILE_TestFrame</A> of course also test the PBL Key File
library.
</UL></BLOCKQUOTE>
<DL><DT><DD></DL><P><P><I><A HREF="index.html">Alphabetic index</A></I></P><HR>
<BR>
This page was generated with the help of <A HREF="http://docpp.sourceforge.net">DOC++</A>.
</BODY>
</HTML>

24
src/pbl/doc/pblKeyFile_t.html
View file

@ -1,24 +0,0 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML>
<HEAD>
<TITLE>typedef struct pblKeyFile_s pblKeyFile_t</TITLE>
<META NAME="GENERATOR" CONTENT="DOC++ 3.4.9">
</HEAD>
<center>
<H2>Program Base Library Functions</H2>
</center>
<H2>typedef struct pblKeyFile_s <A HREF="#DOC.DOCU">pblKeyFile_t</A></H2></H2><BLOCKQUOTE> the key file type the pblKf* functions are dealing with, </BLOCKQUOTE>
<A NAME="DOC.DOCU"></A>
<HR>
<H2>Documentation</H2>
<BLOCKQUOTE>
the key file type the pblKf* functions are dealing with,
the details of the structure are hidden from the user</BLOCKQUOTE>
<DL><DT><DD></DL><P><P><I><A HREF="index.html">Alphabetic index</A></I></P><HR>
<BR>
This page was generated with the help of <A HREF="http://docpp.sourceforge.net">DOC++</A>.
</BODY>
</HTML>

30
src/pbl/doc/pblKfClose.html
View file

@ -1,30 +0,0 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML>
<HEAD>
<TITLE>int pblKfClose</TITLE>
<META NAME="GENERATOR" CONTENT="DOC++ 3.4.9">
</HEAD>
<center>
<H2>Program Base Library Functions</H2>
</center>
<H2>int <A HREF="#DOC.DOCU">pblKfClose</A></H2><H2>( <!1><A HREF="pblKeyFile_t.html">pblKeyFile_t</A>* k )</H2><BLOCKQUOTE> close a key file</BLOCKQUOTE>
<A NAME="DOC.DOCU"></A>
<HR>
<H2>Documentation</H2>
<BLOCKQUOTE>
close a key file
<P>all changes are flushed to disk before,
all memory allocated for the file is released.
<P></BLOCKQUOTE>
<DL><DT><DT><B>Parameters:</B><DD><B>k</B> - key file to close <BR><DT><B>Returns:</B><DD> int rc == 0: call went ok, file is closed
<BR> int rc != 0: some error, see pbl_errno
<BR><DD></DL><P><P><I><A HREF="index.html">Alphabetic index</A></I></P><HR>
<BR>
This page was generated with the help of <A HREF="http://docpp.sourceforge.net">DOC++</A>.
</BODY>
</HTML>

39
src/pbl/doc/pblKfCommit.html
View file

@ -1,39 +0,0 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML>
<HEAD>
<TITLE>int pblKfCommit</TITLE>
<META NAME="GENERATOR" CONTENT="DOC++ 3.4.9">
</HEAD>
<center>
<H2>Program Base Library Functions</H2>
</center>
<H2>int <A HREF="#DOC.DOCU">pblKfCommit</A></H2><H2>( <!1><A HREF="pblKeyFile_t.html">pblKeyFile_t</A>* k, int rollback )</H2><BLOCKQUOTE> commit or rollback changes done during a transaction.</BLOCKQUOTE>
<A NAME="DOC.DOCU"></A>
<HR>
<H2>Documentation</H2>
<BLOCKQUOTE>
commit or rollback changes done during a transaction.
<P>transactions can be nested, if so the commit
only happens when the outermost transaction
calls a commit.
<P>the commit only happens to process space buffer cache,
call <!1><A HREF="pblKfFlush.html">pblKfFlush</A>() after <!1><A HREF="pblKfCommit.html">pblKfCommit</A>() if you want to
flush to kernel space buffer cache.
<P></BLOCKQUOTE>
<DL><DT><DT><B>Parameters:</B><DD><B>k</B> - key file to commit
<BR><B>rollback</B> - != 0: roll back the changes, == 0: commit the changes <BR><DT><B>Returns:</B><DD> int rc == 0: the commit went ok
<BR> int rc > 0: a rollback happened, either because the caller
requested it or because an inner transaction resulted
in a rollback
<BR> int rc < 0: some error, see pbl_errno
<BR><DD></DL><P><P><I><A HREF="index.html">Alphabetic index</A></I></P><HR>
<BR>
This page was generated with the help of <A HREF="http://docpp.sourceforge.net">DOC++</A>.
</BODY>
</HTML>

38
src/pbl/doc/pblKfCreate.html
View file

@ -1,38 +0,0 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML>
<HEAD>
<TITLE>pblKeyFile_t* pblKfCreate</TITLE>
<META NAME="GENERATOR" CONTENT="DOC++ 3.4.9">
</HEAD>
<center>
<H2>Program Base Library Functions</H2>
</center>
<H2><!1><A HREF="pblKeyFile_t.html">pblKeyFile_t</A>* <A HREF="#DOC.DOCU">pblKfCreate</A></H2><H2>( char* path,<BR>&nbsp; void* filesettag )</H2><BLOCKQUOTE> create a key file with the name specified by path.</BLOCKQUOTE>
<A NAME="DOC.DOCU"></A>
<HR>
<H2>Documentation</H2>
<BLOCKQUOTE>
create a key file with the name specified by path.
<P>a file set tag can be attached to the file,
if a file having a non NULL file set tag is flushed
to disk all files having the same file set tag attached
are flushed as well.
<P><P>
<B>RESTRICTIONS</B>:
<BR> - the file to create must not exists.
<BR> - the current record of the file will not be set
<P></BLOCKQUOTE>
<DL><DT><DT><B>Parameters:</B><DD><B>path</B> - path of file to create
<BR><B>filesettag</B> - file set tag, for flushing multiple files consistently <BR><DT><B>Returns:</B><DD> pblKeyFile_t * retptr == NULL: an error occured, see pbl_errno
<BR> pblKeyFile_t * retptr != NULL: a pointer to a key file descriptor
<BR><DD></DL><P><P><I><A HREF="index.html">Alphabetic index</A></I></P><HR>
<BR>
This page was generated with the help of <A HREF="http://docpp.sourceforge.net">DOC++</A>.
</BODY>
</HTML>

40
src/pbl/doc/pblKfDelete.html
View file

@ -1,40 +0,0 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML>
<HEAD>
<TITLE>int pblKfDelete</TITLE>
<META NAME="GENERATOR" CONTENT="DOC++ 3.4.9">
</HEAD>
<center>
<H2>Program Base Library Functions</H2>
</center>
<H2>int <A HREF="#DOC.DOCU">pblKfDelete</A></H2><H2>( <!1><A HREF="pblKeyFile_t.html">pblKeyFile_t</A>* k )</H2><BLOCKQUOTE> delete the current record of the key file.</BLOCKQUOTE>
<A NAME="DOC.DOCU"></A>
<HR>
<H2>Documentation</H2>
<BLOCKQUOTE>
delete the current record of the key file.
<P>the current record of the file is set to the next record or
if the last record is deleted, to the previous record,
<P>if there are no more records in the file after the delete
the current record is of course unpositioned
<P><P>
<B>RESTRICTIONS</B>:
<BR> - the file must be open for update,
<BR> - no space will be given back to the file system,
<BR> - if an index block and its successor or its predeccessor
together use less than half of a block the two blocks are merged
<P></BLOCKQUOTE>
<DL><DT><DT><B>Parameters:</B><DD><B>k</B> - key file to delete record from <BR><DT><B>Returns:</B><DD> int rc == 0: call went ok
<BR> int rc != 0: some error occured, see pbl_errno
<BR><DD></DL><P><P><I><A HREF="index.html">Alphabetic index</A></I></P><HR>
<BR>
This page was generated with the help of <A HREF="http://docpp.sourceforge.net">DOC++</A>.
</BODY>
</HTML>

68
src/pbl/doc/pblKfFind.html
View file

@ -1,68 +0,0 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML>
<HEAD>
<TITLE>long pblKfFind</TITLE>
<META NAME="GENERATOR" CONTENT="DOC++ 3.4.9">
</HEAD>
<center>
<H2>Program Base Library Functions</H2>
</center>
<H2>long <A HREF="#DOC.DOCU">pblKfFind</A></H2><H2>( <!1><A HREF="pblKeyFile_t.html">pblKeyFile_t</A>* k, int mode,<BR>&nbsp; unsigned char* skey, int skeylen,<BR>&nbsp; unsigned char* okey, int* okeylen )</H2><BLOCKQUOTE> find a record in a key file, set the current record</BLOCKQUOTE>
<A NAME="DOC.DOCU"></A>
<HR>
<H2>Documentation</H2>
<BLOCKQUOTE>
find a record in a key file, set the current record
<P>parameter mode specifies which record to find relative
to the search key specified by skey and skeylen.
the following values for mode are possible
<P><BR><B> PBLEQ </B> - find a record whose key is equal to skey
<BR><B> PBLFI </B> - find the first record that is equal
<BR><B> PBLLA </B> - find the last record that is equal
<BR><B> PBLGE </B> - find the last record that is equal or the smallest
record that is greater
<BR><B> PBLGT </B> - find the smallest record that is greater
<BR><B> PBLLE </B> - find the first record that is equal or the biggest
record that is smaller
<BR><B> PBLLT </B> - find the biggest record that is smaller
<P>keep in mind that PBL allows multiple records with the same key.
<P><P>
<B>RESTRICTIONS</B>:
<BR> - the out parameter okey must point to a memory area that is
big enough to hold any possible key, i.e 255 bytes
<P></BLOCKQUOTE>
<DL><DT><DT><B>Parameters:</B><DD><B>k</B> - key file to search in
<BR><B>mode</B> - mode to use for search
<BR><B>skey</B> - key to use for search
<BR><B>skeylen</B> - length of search key
<BR><B>okey</B> - buffer for result key
<BR><B>okeylen</B> - length of the result key after return <BR><DT><B>Returns:</B><DD> long rc >= 0:
<UL>
<LI> call went ok,
the value returned is the length
of the data of the record found,
<LI> the length of the key of the record is set in
the out parameter okeylen,
<LI> the key of the record is copied to okey,
<LI> the current record of the file is set to the
record found
</UL>
<BR> long rc < 0:
<UL>
<LI> some error occured, see pbl_errno
especially PBL_ERROR_NOT_FOUND, if there is no
matching record
</UL>
<BR><DD></DL><P><P><I><A HREF="index.html">Alphabetic index</A></I></P><HR>
<BR>
This page was generated with the help of <A HREF="http://docpp.sourceforge.net">DOC++</A>.
</BODY>
</HTML>

23
src/pbl/doc/pblKfFirst.html
View file

@ -1,23 +0,0 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML>
<HEAD>
<TITLE>#define pblKfFirst</TITLE>
<META NAME="GENERATOR" CONTENT="DOC++ 3.4.9">
</HEAD>
<center>
<H2>Program Base Library Functions</H2>
</center>
<H2>#define <A HREF="#DOC.DOCU">pblKfFirst</A></H2><H2>( KF, K, L )</H2><BLOCKQUOTE> set the current record to the first record of the file</BLOCKQUOTE>
<A NAME="DOC.DOCU"></A>
<HR>
<H2>Documentation</H2>
<BLOCKQUOTE>
set the current record to the first record of the file</BLOCKQUOTE>
<DL><DT><DD></DL><P><P><I><A HREF="index.html">Alphabetic index</A></I></P><HR>
<BR>
This page was generated with the help of <A HREF="http://docpp.sourceforge.net">DOC++</A>.
</BODY>
</HTML>

29
src/pbl/doc/pblKfFlush.html
View file

@ -1,29 +0,0 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML>
<HEAD>
<TITLE>int pblKfFlush</TITLE>
<META NAME="GENERATOR" CONTENT="DOC++ 3.4.9">
</HEAD>
<center>
<H2>Program Base Library Functions</H2>
</center>
<H2>int <A HREF="#DOC.DOCU">pblKfFlush</A></H2><H2>( <!1><A HREF="pblKeyFile_t.html">pblKeyFile_t</A>* k )</H2><BLOCKQUOTE> flush a key file</BLOCKQUOTE>
<A NAME="DOC.DOCU"></A>
<HR>
<H2>Documentation</H2>
<BLOCKQUOTE>
flush a key file
<P>all changes are flushed to disk,
<P></BLOCKQUOTE>
<DL><DT><DT><B>Parameters:</B><DD><B>k</B> - key file to flush <BR><DT><B>Returns:</B><DD> int rc == 0: call went ok
<BR> int rc != 0: some error, see pbl_errno
<BR><DD></DL><P><P><I><A HREF="index.html">Alphabetic index</A></I></P><HR>
<BR>
This page was generated with the help of <A HREF="http://docpp.sourceforge.net">DOC++</A>.
</BODY>
</HTML>

48
src/pbl/doc/pblKfGetAbs.html
View file

@ -1,48 +0,0 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML>
<HEAD>
<TITLE>long pblKfGetAbs</TITLE>
<META NAME="GENERATOR" CONTENT="DOC++ 3.4.9">
</HEAD>
<center>
<H2>Program Base Library Functions</H2>
</center>
<H2>long <A HREF="#DOC.DOCU">pblKfGetAbs</A></H2><H2>( <!1><A HREF="pblKeyFile_t.html">pblKeyFile_t</A>* k, long absindex, char* okey,<BR>&nbsp; int* okeylen )</H2><BLOCKQUOTE> set current record to a record with an absolute position index</BLOCKQUOTE>
<A NAME="DOC.DOCU"></A>
<HR>
<H2>Documentation</H2>
<BLOCKQUOTE>
set current record to a record with an absolute position index
<P>this function is only to be used through the macro functions:
<P><BR><B> <!1><A HREF="pblKfFirst.html">pblKfFirst</A>( k, okey, okeylen ) </B> read key of first record
<BR><B> <!1><A HREF="pblKfLast.html">pblKfLast</A>( k, okey, okeylen ) </B> read key of last record
<P></BLOCKQUOTE>
<DL><DT><DT><B>Parameters:</B><DD><B>k</B> - key file to position in
<BR><B>absindex</B> - index of record to positon to
<BR><B>okey</B> - buffer for result key
<BR><B>okeylen</B> - length of the result key after return <BR><DT><B>Returns:</B><DD> long rc >= 0:
<UL>
<LI> call went ok,
the value returned is the length
of the data of the record found,
<LI> the length of the key of the record is set in
the out parameter okeylen,
<LI> the key of the record is copied to okey,
<LI> the current record of the file is set to the
record found
</UL>
<BR> long rc < 0:
<UL>
<LI> some error occured, see pbl_errno
</UL>
<BR><DD></DL><P><P><I><A HREF="index.html">Alphabetic index</A></I></P><HR>
<BR>
This page was generated with the help of <A HREF="http://docpp.sourceforge.net">DOC++</A>.
</BODY>
</HTML>

49
src/pbl/doc/pblKfGetRel.html
View file

@ -1,49 +0,0 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML>
<HEAD>
<TITLE>long pblKfGetRel</TITLE>
<META NAME="GENERATOR" CONTENT="DOC++ 3.4.9">
</HEAD>
<center>
<H2>Program Base Library Functions</H2>
</center>
<H2>long <A HREF="#DOC.DOCU">pblKfGetRel</A></H2><H2>( <!1><A HREF="pblKeyFile_t.html">pblKeyFile_t</A>* k, long relindex, char* okey,<BR>&nbsp; int* okeylen )</H2><BLOCKQUOTE> set current record to a record with a relative position index</BLOCKQUOTE>
<A NAME="DOC.DOCU"></A>
<HR>
<H2>Documentation</H2>
<BLOCKQUOTE>
set current record to a record with a relative position index
<P>this function is only to be used through the macro functions:
<P><BR><B> <!1><A HREF="pblKfThis.html">pblKfThis</A>( k, okey, okeylen ) </B> read key of current record
<BR><B> <!1><A HREF="pblKfNext.html">pblKfNext</A>( k, okey, okeylen ) </B> read key of next record
<BR><B> <!1><A HREF="pblKfPrev.html">pblKfPrev</A>( k, okey, okeylen ) </B> read key of previous record
<P></BLOCKQUOTE>
<DL><DT><DT><B>Parameters:</B><DD><B>k</B> - key file to position in
<BR><B>relindex</B> - index relative to current record
<BR><B>okey</B> - buffer for result key
<BR><B>okeylen</B> - length of the result key after return <BR><DT><B>Returns:</B><DD> long rc >= 0:
<UL>
<LI> call went ok,
the value returned is the length
of the data of the record found,
<LI> the length of the key of the record is set in
the out parameter okeylen,
<LI> the key of the record is copied to okey,
<LI> the current record of the file is set to the
record found
</UL>
<BR> long rc < 0:
<UL>
<LI> some error occured, see pbl_errno
</UL>
<BR><DD></DL><P><P><I><A HREF="index.html">Alphabetic index</A></I></P><HR>
<BR>
This page was generated with the help of <A HREF="http://docpp.sourceforge.net">DOC++</A>.
</BODY>
</HTML>

28
src/pbl/doc/pblKfInit.html
View file

@ -1,28 +0,0 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML>
<HEAD>
<TITLE>int pblKfInit</TITLE>
<META NAME="GENERATOR" CONTENT="DOC++ 3.4.9">
</HEAD>
<center>
<H2>Program Base Library Functions</H2>
</center>
<H2>int <A HREF="#DOC.DOCU">pblKfInit</A></H2><H2>( int nblocks )</H2><BLOCKQUOTE> change the number of cache blocks used per open key file</BLOCKQUOTE>
<A NAME="DOC.DOCU"></A>
<HR>
<H2>Documentation</H2>
<BLOCKQUOTE>
change the number of cache blocks used per open key file
<P>the default number is 64, a memory block uses about 4096 bytes of heap memory
<P></BLOCKQUOTE>
<DL><DT><DT><B>Returns:</B><DD> int rc: the number of blocks used after the call
<BR><DD></DL><P><P><I><A HREF="index.html">Alphabetic index</A></I></P><HR>
<BR>
This page was generated with the help of <A HREF="http://docpp.sourceforge.net">DOC++</A>.
</BODY>
</HTML>

46
src/pbl/doc/pblKfInsert.html
View file

@ -1,46 +0,0 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML>
<HEAD>
<TITLE>int pblKfInsert</TITLE>
<META NAME="GENERATOR" CONTENT="DOC++ 3.4.9">
</HEAD>
<center>
<H2>Program Base Library Functions</H2>
</center>
<H2>int <A HREF="#DOC.DOCU">pblKfInsert</A></H2><H2>( <!1><A HREF="pblKeyFile_t.html">pblKeyFile_t</A>* k, unsigned char* key,<BR>&nbsp; int keylen, unsigned char* data,<BR>&nbsp; long datalen )</H2><BLOCKQUOTE> insert a new record with the given key and data into a key file,</BLOCKQUOTE>
<A NAME="DOC.DOCU"></A>
<HR>
<H2>Documentation</H2>
<BLOCKQUOTE>
insert a new record with the given key and data into a key file,
<P>multiple records with the same key are allowed,
if there are already records with the same key the new
record will be inserted behind all records with the same key,
<P>the current record of the file will be set to the new record
<P><P>
<B>RESTRICTIONS</B>:
<BR> - the file must be open for update,
<BR> - key must point to the key to be inserted,
<BR> - keylen must be bigger than 0 and smaller than 256,
<BR> - data must point to the data be inserted,
<BR> - datalen must not be negative,
<BR> - if datalen == 0, the pointer data is not evaluated at all
<P></BLOCKQUOTE>
<DL><DT><DT><B>Parameters:</B><DD><B>k</B> - key file to insert to
<BR><B>key</B> - key to insert
<BR><B>keylen</B> - length of the key
<BR><B>data</B> - data to insert
<BR><B>datalen</B> - length of the data <BR><DT><B>Returns:</B><DD> int rc == 0: call went ok
<BR> int rc != 0: some error occured, see pbl_errno
<BR><DD></DL><P><P><I><A HREF="index.html">Alphabetic index</A></I></P><HR>
<BR>
This page was generated with the help of <A HREF="http://docpp.sourceforge.net">DOC++</A>.
</BODY>
</HTML>

23
src/pbl/doc/pblKfLast.html
View file

@ -1,23 +0,0 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML>
<HEAD>
<TITLE>#define pblKfLast</TITLE>
<META NAME="GENERATOR" CONTENT="DOC++ 3.4.9">
</HEAD>
<center>
<H2>Program Base Library Functions</H2>
</center>
<H2>#define <A HREF="#DOC.DOCU">pblKfLast</A></H2><H2>( KF, K, L )</H2><BLOCKQUOTE> set the current record to the last record of the file</BLOCKQUOTE>
<A NAME="DOC.DOCU"></A>
<HR>
<H2>Documentation</H2>
<BLOCKQUOTE>
set the current record to the last record of the file</BLOCKQUOTE>
<DL><DT><DD></DL><P><P><I><A HREF="index.html">Alphabetic index</A></I></P><HR>
<BR>
This page was generated with the help of <A HREF="http://docpp.sourceforge.net">DOC++</A>.
</BODY>
</HTML>

23
src/pbl/doc/pblKfNext.html
View file

@ -1,23 +0,0 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML>
<HEAD>
<TITLE>#define pblKfNext</TITLE>
<META NAME="GENERATOR" CONTENT="DOC++ 3.4.9">
</HEAD>
<center>
<H2>Program Base Library Functions</H2>
</center>
<H2>#define <A HREF="#DOC.DOCU">pblKfNext</A></H2><H2>( KF, K, L )</H2><BLOCKQUOTE> set the current record to the next record of the file</BLOCKQUOTE>
<A NAME="DOC.DOCU"></A>
<HR>
<H2>Documentation</H2>
<BLOCKQUOTE>
set the current record to the next record of the file</BLOCKQUOTE>
<DL><DT><DD></DL><P><P><I><A HREF="index.html">Alphabetic index</A></I></P><HR>
<BR>
This page was generated with the help of <A HREF="http://docpp.sourceforge.net">DOC++</A>.
</BODY>
</HTML>

42
src/pbl/doc/pblKfOpen.html
View file

@ -1,42 +0,0 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML>
<HEAD>
<TITLE>pblKeyFile_t* pblKfOpen</TITLE>
<META NAME="GENERATOR" CONTENT="DOC++ 3.4.9">
</HEAD>
<center>
<H2>Program Base Library Functions</H2>
</center>
<H2><!1><A HREF="pblKeyFile_t.html">pblKeyFile_t</A>* <A HREF="#DOC.DOCU">pblKfOpen</A></H2><H2>( char* path,<BR>&nbsp; int update,<BR>&nbsp; void* filesettag )</H2><BLOCKQUOTE> open an existing key file</BLOCKQUOTE>
<A NAME="DOC.DOCU"></A>
<HR>
<H2>Documentation</H2>
<BLOCKQUOTE>
open an existing key file
<P>if update is 0, the file is opened for read access only,
if update is not 0 the file is opened for reading and writing
<P>a file set tag can be attached to the file,
if a file having a non NULL file set tag is flushed
to disk all files having the same file set tag attached
are flushed as well.
<P><P>
<B>RESTRICTIONS</B>:
<BR> - the file must exist already
<BR> - the current record of the file will not be set
<P></BLOCKQUOTE>
<DL><DT><DT><B>Parameters:</B><DD><B>path</B> - path of file to create
<BR><B>update</B> - flag: should file be opened for update?
<BR><B>filesettag</B> - file set tag, for flushing multiple files consistently <BR><DT><B>Returns:</B><DD> pblKeyFile_t * retptr == NULL: an error occured, see pbl_errno
<BR> pblKeyFile_t * retptr != NULL: a pointer to a key file descriptor
<BR><DD></DL><P><P><I><A HREF="index.html">Alphabetic index</A></I></P><HR>
<BR>
This page was generated with the help of <A HREF="http://docpp.sourceforge.net">DOC++</A>.
</BODY>
</HTML>

23
src/pbl/doc/pblKfPrev.html
View file

@ -1,23 +0,0 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML>
<HEAD>
<TITLE>#define pblKfPrev</TITLE>
<META NAME="GENERATOR" CONTENT="DOC++ 3.4.9">
</HEAD>
<center>
<H2>Program Base Library Functions</H2>
</center>
<H2>#define <A HREF="#DOC.DOCU">pblKfPrev</A></H2><H2>( KF, K, L )</H2><BLOCKQUOTE> set the current record to the previous record of the file</BLOCKQUOTE>
<A NAME="DOC.DOCU"></A>
<HR>
<H2>Documentation</H2>
<BLOCKQUOTE>
set the current record to the previous record of the file</BLOCKQUOTE>
<DL><DT><DD></DL><P><P><I><A HREF="index.html">Alphabetic index</A></I></P><HR>
<BR>
This page was generated with the help of <A HREF="http://docpp.sourceforge.net">DOC++</A>.
</BODY>
</HTML>

39
src/pbl/doc/pblKfRead.html
View file

@ -1,39 +0,0 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML>
<HEAD>
<TITLE>long pblKfRead</TITLE>
<META NAME="GENERATOR" CONTENT="DOC++ 3.4.9">
</HEAD>
<center>
<H2>Program Base Library Functions</H2>
</center>
<H2>long <A HREF="#DOC.DOCU">pblKfRead</A></H2><H2>( <!1><A HREF="pblKeyFile_t.html">pblKeyFile_t</A>* k, unsigned char* data,<BR>&nbsp; long datalen )</H2><BLOCKQUOTE> read the data of the current record of the file</BLOCKQUOTE>
<A NAME="DOC.DOCU"></A>
<HR>
<H2>Documentation</H2>
<BLOCKQUOTE>
read the data of the current record of the file
<P>the caller can restrict the number of bytes read by
specifying the maximum number of bytes to read by parameter
datalen, if datalen is 0, all bytes stored for the
current record are copied to the buffer pointed to by data.
<P>
<B>RESTRICTIONS</B>:
<BR> - data must point to an area of memory being big enough to hold
the bytes copied
<BR> - datalen must not be negative, it is ignored otherwise
<P></BLOCKQUOTE>
<DL><DT><DT><B>Parameters:</B><DD><B>k</B> - key file to read from
<BR><B>data</B> - data to insert
<BR><B>datalen</B> - length of the data <BR><DT><B>Returns:</B><DD> int rc == 0: call went ok, rc is the number of bytes copied
<BR> int rc != 0: some error occured, see pbl_errno
<BR><DD></DL><P><P><I><A HREF="index.html">Alphabetic index</A></I></P><HR>
<BR>
This page was generated with the help of <A HREF="http://docpp.sourceforge.net">DOC++</A>.
</BODY>
</HTML>

28
src/pbl/doc/pblKfRestorePosition.html
View file

@ -1,28 +0,0 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML>
<HEAD>
<TITLE>int pblKfRestorePosition</TITLE>
<META NAME="GENERATOR" CONTENT="DOC++ 3.4.9">
</HEAD>
<center>
<H2>Program Base Library Functions</H2>
</center>
<H2>int <A HREF="#DOC.DOCU">pblKfRestorePosition</A></H2><H2>( <!1><A HREF="pblKeyFile_t.html">pblKeyFile_t</A>* k )</H2><BLOCKQUOTE> restore the position of the current record saved by the last previous call to <!1><A HREF="pblKfSavePosition.html">pblKfSavePosition</A>().</BLOCKQUOTE>
<A NAME="DOC.DOCU"></A>
<HR>
<H2>Documentation</H2>
<BLOCKQUOTE>
restore the position of the current record saved by the
last previous call to <!1><A HREF="pblKfSavePosition.html">pblKfSavePosition</A>().
<P></BLOCKQUOTE>
<DL><DT><DT><B>Parameters:</B><DD><B>k</B> - key file to restore position for <BR><DT><B>Returns:</B><DD> int rc == 0: the position was restored
<BR> int rc < 0: an error, see pbl_errno
<BR><DD></DL><P><P><I><A HREF="index.html">Alphabetic index</A></I></P><HR>
<BR>
This page was generated with the help of <A HREF="http://docpp.sourceforge.net">DOC++</A>.
</BODY>
</HTML>

27
src/pbl/doc/pblKfSavePosition.html
View file

@ -1,27 +0,0 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML>
<HEAD>
<TITLE>int pblKfSavePosition</TITLE>
<META NAME="GENERATOR" CONTENT="DOC++ 3.4.9">
</HEAD>
<center>
<H2>Program Base Library Functions</H2>
</center>
<H2>int <A HREF="#DOC.DOCU">pblKfSavePosition</A></H2><H2>( <!1><A HREF="pblKeyFile_t.html">pblKeyFile_t</A>* k )</H2><BLOCKQUOTE> save the position of the current record for later restore</BLOCKQUOTE>
<A NAME="DOC.DOCU"></A>
<HR>
<H2>Documentation</H2>
<BLOCKQUOTE>
save the position of the current record for later restore
<P></BLOCKQUOTE>
<DL><DT><DT><B>Parameters:</B><DD><B>k</B> - key file to save position for <BR><DT><B>Returns:</B><DD> int rc == 0: the position was saved
<BR> int rc < 0: an error, see pbl_errno
<BR><DD></DL><P><P><I><A HREF="index.html">Alphabetic index</A></I></P><HR>
<BR>
This page was generated with the help of <A HREF="http://docpp.sourceforge.net">DOC++</A>.
</BODY>
</HTML>

38
src/pbl/doc/pblKfSetCompareFunction.html
View file

@ -1,38 +0,0 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML>
<HEAD>
<TITLE>void pblKfSetCompareFunction</TITLE>
<META NAME="GENERATOR" CONTENT="DOC++ 3.4.9">
</HEAD>
<center>
<H2>Program Base Library Functions</H2>
</center>
<H2>void <A HREF="#DOC.DOCU">pblKfSetCompareFunction</A></H2><H2>( <!1><A HREF="pblKeyFile_t.html">pblKeyFile_t</A>* k,<BR>&nbsp; int (* keycompare ) ( void* left,<BR>&nbsp; size_t llen, void* right,<BR>&nbsp; size_t rlen ) )</H2><BLOCKQUOTE> set an application specific compare function for the keys of a key file</BLOCKQUOTE>
<A NAME="DOC.DOCU"></A>
<HR>
<H2>Documentation</H2>
<BLOCKQUOTE>
set an application specific compare function for the keys of a key file
<P>an application specific compare function can be used in order to
implement special orderings of the values of an index, e.g.
because of the use of european "umlauts" in names
<P>the default compare function is the c-library memcmp function
the keycompare function should behave like memcmp
<P></BLOCKQUOTE>
<DL><DT><DT><B>Parameters:</B><DD><B>k</B> - key file to set compare function for
<BR><B>keycompare</B> - compare function to set
<BR><B>left</B> - "left" buffer for compare
<BR><B>llen</B> - length of that buffer
<BR><B>right</B> - "right" buffer for compare
<BR><B>rlen</B> - length of that buffer <BR><DT><B>Returns:</B><DD> void
<BR><DD></DL><P><P><I><A HREF="index.html">Alphabetic index</A></I></P><HR>
<BR>
This page was generated with the help of <A HREF="http://docpp.sourceforge.net">DOC++</A>.
</BODY>
</HTML>

31
src/pbl/doc/pblKfStartTransaction.html
View file

@ -1,31 +0,0 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML>
<HEAD>
<TITLE>int pblKfStartTransaction</TITLE>
<META NAME="GENERATOR" CONTENT="DOC++ 3.4.9">
</HEAD>
<center>
<H2>Program Base Library Functions</H2>
</center>
<H2>int <A HREF="#DOC.DOCU">pblKfStartTransaction</A></H2><H2>( <!1><A HREF="pblKeyFile_t.html">pblKeyFile_t</A>* k )</H2><BLOCKQUOTE> start a transaction on a key file</BLOCKQUOTE>
<A NAME="DOC.DOCU"></A>
<HR>
<H2>Documentation</H2>
<BLOCKQUOTE>
start a transaction on a key file
<P>transactions can be nested
<P></BLOCKQUOTE>
<DL><DT><DT><B>Parameters:</B><DD><B>k</B> - key file to start transaction on <BR><DT><B>Returns:</B><DD> int rc == 0: the transaction was started successfully
<BR> int rc > 0: the transaction was started
but another transaction has resulted in
a rollback request on the file already
<BR><DD></DL><P><P><I><A HREF="index.html">Alphabetic index</A></I></P><HR>
<BR>
This page was generated with the help of <A HREF="http://docpp.sourceforge.net">DOC++</A>.
</BODY>
</HTML>

23
src/pbl/doc/pblKfThis.html
View file

@ -1,23 +0,0 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML>
<HEAD>
<TITLE>#define pblKfThis</TITLE>
<META NAME="GENERATOR" CONTENT="DOC++ 3.4.9">
</HEAD>
<center>
<H2>Program Base Library Functions</H2>
</center>
<H2>#define <A HREF="#DOC.DOCU">pblKfThis</A></H2><H2>( KF, K, L )</H2><BLOCKQUOTE> return the datalen of the current record</BLOCKQUOTE>
<A NAME="DOC.DOCU"></A>
<HR>
<H2>Documentation</H2>
<BLOCKQUOTE>
return the datalen of the current record</BLOCKQUOTE>
<DL><DT><DD></DL><P><P><I><A HREF="index.html">Alphabetic index</A></I></P><HR>
<BR>
This page was generated with the help of <A HREF="http://docpp.sourceforge.net">DOC++</A>.
</BODY>
</HTML>

43
src/pbl/doc/pblKfUpdate.html
View file

@ -1,43 +0,0 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML>
<HEAD>
<TITLE>int pblKfUpdate</TITLE>
<META NAME="GENERATOR" CONTENT="DOC++ 3.4.9">
</HEAD>
<center>
<H2>Program Base Library Functions</H2>
</center>
<H2>int <A HREF="#DOC.DOCU">pblKfUpdate</A></H2><H2>( <!1><A HREF="pblKeyFile_t.html">pblKeyFile_t</A>* k, unsigned char* data,<BR>&nbsp; long datalen )</H2><BLOCKQUOTE> update the data of the current record</BLOCKQUOTE>
<A NAME="DOC.DOCU"></A>
<HR>
<H2>Documentation</H2>
<BLOCKQUOTE>
update the data of the current record
<P>the current record of the file is updated with the new data given
<P>
<P>
<B>RESTRICTIONS</B>:
<BR> - the file must be open for update,
<BR> - if the new datalen of the record is not bigger than the old datalen,
the data will be updated in place, otherwise the new data of the
record will be appended to the file, the space previously used for
the data of the record will not be reused in this case,
<BR> - data must point to the new data be inserted,
<BR> - datalen must not be negative,
<BR> - if datalen == 0, the pointer data is not evaluated at all
<P></BLOCKQUOTE>
<DL><DT><DT><B>Parameters:</B><DD><B>k</B> - key file to delete record from
<BR><B>data</B> - new data to update with
<BR><B>datalen</B> - length of the new data <BR><DT><B>Returns:</B><DD> int rc == 0: call went ok
<BR> int rc != 0: some error occured, see pbl_errno
<BR><DD></DL><P><P><I><A HREF="index.html">Alphabetic index</A></I></P><HR>
<BR>
This page was generated with the help of <A HREF="http://docpp.sourceforge.net">DOC++</A>.
</BODY>
</HTML>

26
src/pbl/doc/pbl_BufToLong.html
View file

@ -1,26 +0,0 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML>
<HEAD>
<TITLE>long pbl_BufToLong</TITLE>
<META NAME="GENERATOR" CONTENT="DOC++ 3.4.9">
</HEAD>
<center>
<H2>Program Base Library Functions</H2>
</center>
<H2>long <A HREF="#DOC.DOCU">pbl_BufToLong</A></H2><H2>( unsigned char* buf )</H2><BLOCKQUOTE> read a four byte long from a four byte buffer</BLOCKQUOTE>
<A NAME="DOC.DOCU"></A>
<HR>
<H2>Documentation</H2>
<BLOCKQUOTE>
read a four byte long from a four byte buffer
<P></BLOCKQUOTE>
<DL><DT><DT><B>Parameters:</B><DD><B>buf</B> - the buffer to read from <BR><DT><B>Returns:</B><DD> long ret: the long value read
<BR><DD></DL><P><P><I><A HREF="index.html">Alphabetic index</A></I></P><HR>
<BR>
This page was generated with the help of <A HREF="http://docpp.sourceforge.net">DOC++</A>.
</BODY>
</HTML>

26
src/pbl/doc/pbl_BufToShort.html
View file

@ -1,26 +0,0 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML>
<HEAD>
<TITLE>int pbl_BufToShort</TITLE>
<META NAME="GENERATOR" CONTENT="DOC++ 3.4.9">
</HEAD>
<center>
<H2>Program Base Library Functions</H2>
</center>
<H2>int <A HREF="#DOC.DOCU">pbl_BufToShort</A></H2><H2>( unsigned char* buf )</H2><BLOCKQUOTE> read a two byte short from a two byte buffer</BLOCKQUOTE>
<A NAME="DOC.DOCU"></A>
<HR>
<H2>Documentation</H2>
<BLOCKQUOTE>
read a two byte short from a two byte buffer
<P></BLOCKQUOTE>
<DL><DT><DT><B>Parameters:</B><DD><B>buf</B> - buffer to read from <BR><DT><B>Returns:</B><DD> int rc: the short value read
<BR><DD></DL><P><P><I><A HREF="index.html">Alphabetic index</A></I></P><HR>
<BR>
This page was generated with the help of <A HREF="http://docpp.sourceforge.net">DOC++</A>.
</BODY>
</HTML>

26
src/pbl/doc/pbl_LongSize.html
View file

@ -1,26 +0,0 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML>
<HEAD>
<TITLE>int pbl_LongSize</TITLE>
<META NAME="GENERATOR" CONTENT="DOC++ 3.4.9">
</HEAD>
<center>
<H2>Program Base Library Functions</H2>
</center>
<H2>int <A HREF="#DOC.DOCU">pbl_LongSize</A></H2><H2>( unsigned long value )</H2><BLOCKQUOTE> find out how many bytes a four byte long would use in a buffer</BLOCKQUOTE>
<A NAME="DOC.DOCU"></A>
<HR>
<H2>Documentation</H2>
<BLOCKQUOTE>
find out how many bytes a four byte long would use in a buffer
<P></BLOCKQUOTE>
<DL><DT><DT><B>Parameters:</B><DD><B>value</B> - value to check <BR><DT><B>Returns:</B><DD> int rc: number of bytes used in buffer
<BR><DD></DL><P><P><I><A HREF="index.html">Alphabetic index</A></I></P><HR>
<BR>
This page was generated with the help of <A HREF="http://docpp.sourceforge.net">DOC++</A>.
</BODY>
</HTML>

25
src/pbl/doc/pbl_LongToBuf.html
View file

@ -1,25 +0,0 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML>
<HEAD>
<TITLE>void pbl_LongToBuf</TITLE>
<META NAME="GENERATOR" CONTENT="DOC++ 3.4.9">
</HEAD>
<center>
<H2>Program Base Library Functions</H2>
</center>
<H2>void <A HREF="#DOC.DOCU">pbl_LongToBuf</A></H2><H2>( unsigned char* buf, long l )</H2><BLOCKQUOTE> copy a four byte long to a four byte buffer </BLOCKQUOTE>
<A NAME="DOC.DOCU"></A>
<HR>
<H2>Documentation</H2>
<BLOCKQUOTE>
copy a four byte long to a four byte buffer
</BLOCKQUOTE>
<DL><DT><DT><B>Parameters:</B><DD><B>buf</B> - buffer to copy to
<BR><B>l</B> - long value to copy <BR><DD></DL><P><P><I><A HREF="index.html">Alphabetic index</A></I></P><HR>
<BR>
This page was generated with the help of <A HREF="http://docpp.sourceforge.net">DOC++</A>.
</BODY>
</HTML>

25
src/pbl/doc/pbl_LongToVarBuf.html
View file

@ -1,25 +0,0 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML>
<HEAD>
<TITLE>int pbl_LongToVarBuf</TITLE>
<META NAME="GENERATOR" CONTENT="DOC++ 3.4.9">
</HEAD>
<center>
<H2>Program Base Library Functions</H2>
</center>
<H2>int <A HREF="#DOC.DOCU">pbl_LongToVarBuf</A></H2><H2>( unsigned char* buffer,<BR>&nbsp; unsigned long value )</H2><BLOCKQUOTE> copy a four byte long to a variable length buffer</BLOCKQUOTE>
<A NAME="DOC.DOCU"></A>
<HR>
<H2>Documentation</H2>
<BLOCKQUOTE>
copy a four byte long to a variable length buffer
<P></BLOCKQUOTE>
<DL><DT><DT><B>Returns:</B><DD> int rc: the number of bytes used in the buffer<BR><DD></DL><P><P><I><A HREF="index.html">Alphabetic index</A></I></P><HR>
<BR>
This page was generated with the help of <A HREF="http://docpp.sourceforge.net">DOC++</A>.
</BODY>
</HTML>

25
src/pbl/doc/pbl_ShortToBuf.html
View file

@ -1,25 +0,0 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML>
<HEAD>
<TITLE>void pbl_ShortToBuf</TITLE>
<META NAME="GENERATOR" CONTENT="DOC++ 3.4.9">
</HEAD>
<center>
<H2>Program Base Library Functions</H2>
</center>
<H2>void <A HREF="#DOC.DOCU">pbl_ShortToBuf</A></H2><H2>( unsigned char* buf, int s )</H2><BLOCKQUOTE> copy a two byte short to a two byte buffer </BLOCKQUOTE>
<A NAME="DOC.DOCU"></A>
<HR>
<H2>Documentation</H2>
<BLOCKQUOTE>
copy a two byte short to a two byte buffer
</BLOCKQUOTE>
<DL><DT><DT><B>Parameters:</B><DD><B>buf</B> - buffer to copy to
<BR><B>s</B> - short value to copy <BR><DD></DL><P><P><I><A HREF="index.html">Alphabetic index</A></I></P><HR>
<BR>
This page was generated with the help of <A HREF="http://docpp.sourceforge.net">DOC++</A>.
</BODY>
</HTML>

26
src/pbl/doc/pbl_VarBufSize.html
View file

@ -1,26 +0,0 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML>
<HEAD>
<TITLE>int pbl_VarBufSize</TITLE>
<META NAME="GENERATOR" CONTENT="DOC++ 3.4.9">
</HEAD>
<center>
<H2>Program Base Library Functions</H2>
</center>
<H2>int <A HREF="#DOC.DOCU">pbl_VarBufSize</A></H2><H2>( unsigned char* buffer )</H2><BLOCKQUOTE> find out how many bytes a four byte long uses in a buffer</BLOCKQUOTE>
<A NAME="DOC.DOCU"></A>
<HR>
<H2>Documentation</H2>
<BLOCKQUOTE>
find out how many bytes a four byte long uses in a buffer
<P></BLOCKQUOTE>
<DL><DT><DT><B>Parameters:</B><DD><B>buffer</B> - buffer to check <BR><DT><B>Returns:</B><DD> int rc: number of bytes used in buffer
<BR><DD></DL><P><P><I><A HREF="index.html">Alphabetic index</A></I></P><HR>
<BR>
This page was generated with the help of <A HREF="http://docpp.sourceforge.net">DOC++</A>.
</BODY>
</HTML>

27
src/pbl/doc/pbl_VarBufToLong.html
View file

@ -1,27 +0,0 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML>
<HEAD>
<TITLE>int pbl_VarBufToLong</TITLE>
<META NAME="GENERATOR" CONTENT="DOC++ 3.4.9">
</HEAD>
<center>
<H2>Program Base Library Functions</H2>
</center>
<H2>int <A HREF="#DOC.DOCU">pbl_VarBufToLong</A></H2><H2>( unsigned char* buffer, long* value )</H2><BLOCKQUOTE> read a four byte long from a variable length buffer</BLOCKQUOTE>
<A NAME="DOC.DOCU"></A>
<HR>
<H2>Documentation</H2>
<BLOCKQUOTE>
read a four byte long from a variable length buffer
<P></BLOCKQUOTE>
<DL><DT><DT><B>Parameters:</B><DD><B>buffer</B> - buffer to read from
<BR><B>value</B> - long to read to <BR><DT><B>Returns:</B><DD> int rc: the number of bytes used in the buffer
<BR><DD></DL><P><P><I><A HREF="index.html">Alphabetic index</A></I></P><HR>
<BR>
This page was generated with the help of <A HREF="http://docpp.sourceforge.net">DOC++</A>.
</BODY>
</HTML>

23
src/pbl/doc/pbl_errno.html
View file

@ -1,23 +0,0 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML>
<HEAD>
<TITLE>extern int pbl_errno</TITLE>
<META NAME="GENERATOR" CONTENT="DOC++ 3.4.9">
</HEAD>
<center>
<H2>Program Base Library Functions</H2>
</center>
<H2>extern int <A HREF="#DOC.DOCU">pbl_errno</A></H2></H2><BLOCKQUOTE> integer value used for returning error codes</BLOCKQUOTE>
<A NAME="DOC.DOCU"></A>
<HR>
<H2>Documentation</H2>
<BLOCKQUOTE>
integer value used for returning error codes</BLOCKQUOTE>
<DL><DT><DD></DL><P><P><I><A HREF="index.html">Alphabetic index</A></I></P><HR>
<BR>
This page was generated with the help of <A HREF="http://docpp.sourceforge.net">DOC++</A>.
</BODY>
</HTML>

23
src/pbl/doc/pbl_errstr.html
View file

@ -1,23 +0,0 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML>
<HEAD>
<TITLE>extern char* pbl_errstr</TITLE>
<META NAME="GENERATOR" CONTENT="DOC++ 3.4.9">
</HEAD>
<center>
<H2>Program Base Library Functions</H2>
</center>
<H2>extern char* <A HREF="#DOC.DOCU">pbl_errstr</A></H2></H2><BLOCKQUOTE> character buffer used for returning error strings</BLOCKQUOTE>
<A NAME="DOC.DOCU"></A>
<HR>
<H2>Documentation</H2>
<BLOCKQUOTE>
character buffer used for returning error strings</BLOCKQUOTE>
<DL><DT><DD></DL><P><P><I><A HREF="index.html">Alphabetic index</A></I></P><HR>
<BR>
This page was generated with the help of <A HREF="http://docpp.sourceforge.net">DOC++</A>.
</BODY>
</HTML>

28
src/pbl/doc/pbl_malloc.html
View file

@ -1,28 +0,0 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML>
<HEAD>
<TITLE>void* pbl_malloc</TITLE>
<META NAME="GENERATOR" CONTENT="DOC++ 3.4.9">
</HEAD>
<center>
<H2>Program Base Library Functions</H2>
</center>
<H2>void* <A HREF="#DOC.DOCU">pbl_malloc</A></H2><H2>( char* tag, size_t size )</H2><BLOCKQUOTE> replacement for malloc</BLOCKQUOTE>
<A NAME="DOC.DOCU"></A>
<HR>
<H2>Documentation</H2>
<BLOCKQUOTE>
replacement for malloc
<P></BLOCKQUOTE>
<DL><DT><DT><B>Parameters:</B><DD><B>tag</B> - tag used for memory leak detection
<BR><B>size</B> - number of bytes to allocate <BR><DT><B>Returns:</B><DD> void * retptr == NULL: OUT OF MEMORY
<BR> void * retptr != NULL: pointer to buffer allocated
<BR><DD></DL><P><P><I><A HREF="index.html">Alphabetic index</A></I></P><HR>
<BR>
This page was generated with the help of <A HREF="http://docpp.sourceforge.net">DOC++</A>.
</BODY>
</HTML>

28
src/pbl/doc/pbl_malloc0.html
View file

@ -1,28 +0,0 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML>
<HEAD>
<TITLE>void* pbl_malloc0</TITLE>
<META NAME="GENERATOR" CONTENT="DOC++ 3.4.9">
</HEAD>
<center>
<H2>Program Base Library Functions</H2>
</center>
<H2>void* <A HREF="#DOC.DOCU">pbl_malloc0</A></H2><H2>( char* tag, size_t size )</H2><BLOCKQUOTE> replacement for malloc, initializes the memory to 0</BLOCKQUOTE>
<A NAME="DOC.DOCU"></A>
<HR>
<H2>Documentation</H2>
<BLOCKQUOTE>
replacement for malloc, initializes the memory to 0
<P></BLOCKQUOTE>
<DL><DT><DT><B>Parameters:</B><DD><B>tag</B> - tag used for memory leak detection
<BR><B>size</B> - number of bytes to allocate <BR><DT><B>Returns:</B><DD> void * retptr == NULL: OUT OF MEMORY
<BR> void * retptr != NULL: pointer to buffer allocated
<BR><DD></DL><P><P><I><A HREF="index.html">Alphabetic index</A></I></P><HR>
<BR>
This page was generated with the help of <A HREF="http://docpp.sourceforge.net">DOC++</A>.
</BODY>
</HTML>

31
src/pbl/doc/pbl_mem2dup.html
View file

@ -1,31 +0,0 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML>
<HEAD>
<TITLE>void* pbl_mem2dup</TITLE>
<META NAME="GENERATOR" CONTENT="DOC++ 3.4.9">
</HEAD>
<center>
<H2>Program Base Library Functions</H2>
</center>
<H2>void* <A HREF="#DOC.DOCU">pbl_mem2dup</A></H2><H2>( char* tag, void* mem1, size_t len1,<BR>&nbsp; void* mem2, size_t len2 )</H2><BLOCKQUOTE> duplicate and concatenate two memory buffers</BLOCKQUOTE>
<A NAME="DOC.DOCU"></A>
<HR>
<H2>Documentation</H2>
<BLOCKQUOTE>
duplicate and concatenate two memory buffers
<P></BLOCKQUOTE>
<DL><DT><DT><B>Parameters:</B><DD><B>tag</B> - tag used for memory leak detection
<BR><B>mem1</B> - first buffer to duplicate
<BR><B>len1</B> - length of first buffer
<BR><B>mem2</B> - second buffer to duplicate
<BR><B>len2</B> - length of second buffer <BR><DT><B>Returns:</B><DD> void * retptr == NULL: OUT OF MEMORY
<BR> void * retptr != NULL: pointer to new buffer allocated
<BR><DD></DL><P><P><I><A HREF="index.html">Alphabetic index</A></I></P><HR>
<BR>
This page was generated with the help of <A HREF="http://docpp.sourceforge.net">DOC++</A>.
</BODY>
</HTML>

31
src/pbl/doc/pbl_memcmp.html
View file

@ -1,31 +0,0 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML>
<HEAD>
<TITLE>int pbl_memcmp</TITLE>
<META NAME="GENERATOR" CONTENT="DOC++ 3.4.9">
</HEAD>
<center>
<H2>Program Base Library Functions</H2>
</center>
<H2>int <A HREF="#DOC.DOCU">pbl_memcmp</A></H2><H2>( void* left, size_t llen, void* right,<BR>&nbsp; size_t rlen )</H2><BLOCKQUOTE> compare two memory buffers, similar to memcmp</BLOCKQUOTE>
<A NAME="DOC.DOCU"></A>
<HR>
<H2>Documentation</H2>
<BLOCKQUOTE>
compare two memory buffers, similar to memcmp
<P></BLOCKQUOTE>
<DL><DT><DT><B>Parameters:</B><DD><B>left</B> - first buffer for compare
<BR><B>llen</B> - length of that buffer
<BR><B>right</B> - second buffer for compare
<BR><B>rlen</B> - length of that buffer <BR><DT><B>Returns:</B><DD> int rc < 0: left is smaller than right
<BR> int rc == 0: left and right are equal
<BR> int rc > 0: left is bigger than right
<BR><DD></DL><P><P><I><A HREF="index.html">Alphabetic index</A></I></P><HR>
<BR>
This page was generated with the help of <A HREF="http://docpp.sourceforge.net">DOC++</A>.
</BODY>
</HTML>

29
src/pbl/doc/pbl_memcmplen.html
View file

@ -1,29 +0,0 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML>
<HEAD>
<TITLE>int pbl_memcmplen</TITLE>
<META NAME="GENERATOR" CONTENT="DOC++ 3.4.9">
</HEAD>
<center>
<H2>Program Base Library Functions</H2>
</center>
<H2>int <A HREF="#DOC.DOCU">pbl_memcmplen</A></H2><H2>( void* left, size_t llen, void* right,<BR>&nbsp; size_t rlen )</H2><BLOCKQUOTE> find out how many starting bytes of two buffers are equal</BLOCKQUOTE>
<A NAME="DOC.DOCU"></A>
<HR>
<H2>Documentation</H2>
<BLOCKQUOTE>
find out how many starting bytes of two buffers are equal
<P></BLOCKQUOTE>
<DL><DT><DT><B>Parameters:</B><DD><B>left</B> - first buffer for compare
<BR><B>llen</B> - length of that buffer
<BR><B>right</B> - second buffer for compare
<BR><B>rlen</B> - length of that buffer <BR><DT><B>Returns:</B><DD> int rc: number of equal bytes
<BR><DD></DL><P><P><I><A HREF="index.html">Alphabetic index</A></I></P><HR>
<BR>
This page was generated with the help of <A HREF="http://docpp.sourceforge.net">DOC++</A>.
</BODY>
</HTML>

29
src/pbl/doc/pbl_memdup.html
View file

@ -1,29 +0,0 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML>
<HEAD>
<TITLE>void* pbl_memdup</TITLE>
<META NAME="GENERATOR" CONTENT="DOC++ 3.4.9">
</HEAD>
<center>
<H2>Program Base Library Functions</H2>
</center>
<H2>void* <A HREF="#DOC.DOCU">pbl_memdup</A></H2><H2>( char* tag, void* data, size_t size )</H2><BLOCKQUOTE> duplicate a buffer, similar to strdup</BLOCKQUOTE>
<A NAME="DOC.DOCU"></A>
<HR>
<H2>Documentation</H2>
<BLOCKQUOTE>
duplicate a buffer, similar to strdup
<P></BLOCKQUOTE>
<DL><DT><DT><B>Parameters:</B><DD><B>tag</B> - tag used for memory leak detection
<BR><B>data</B> - buffer to duplicate
<BR><B>size</B> - size of that buffer <BR><DT><B>Returns:</B><DD> void * retptr == NULL: OUT OF MEMORY
<BR> void * retptr != NULL: pointer to buffer allocated
<BR><DD></DL><P><P><I><A HREF="index.html">Alphabetic index</A></I></P><HR>
<BR>
This page was generated with the help of <A HREF="http://docpp.sourceforge.net">DOC++</A>.
</BODY>
</HTML>

29
src/pbl/doc/pbl_memlcpy.html
View file

@ -1,29 +0,0 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML>
<HEAD>
<TITLE>size_t pbl_memlcpy</TITLE>
<META NAME="GENERATOR" CONTENT="DOC++ 3.4.9">
</HEAD>
<center>
<H2>Program Base Library Functions</H2>
</center>
<H2>size_t <A HREF="#DOC.DOCU">pbl_memlcpy</A></H2><H2>( void* to, size_t tolen, void* from,<BR>&nbsp; size_t n )</H2><BLOCKQUOTE> memcpy with target length check</BLOCKQUOTE>
<A NAME="DOC.DOCU"></A>
<HR>
<H2>Documentation</H2>
<BLOCKQUOTE>
memcpy with target length check
<P></BLOCKQUOTE>
<DL><DT><DT><B>Parameters:</B><DD><B>to</B> - target buffer to copy to
<BR><B>tolen</B> - number of bytes in the target buffer
<BR><B>from</B> - source to copy from
<BR><B>n</B> - length of source <BR><DT><B>Returns:</B><DD> size_t rc: number of bytes copied
<BR><DD></DL><P><P><I><A HREF="index.html">Alphabetic index</A></I></P><HR>
<BR>
This page was generated with the help of <A HREF="http://docpp.sourceforge.net">DOC++</A>.
</BODY>
</HTML>

340
src/pbl/gpl2.txt
View file

@ -1,340 +0,0 @@
GNU GENERAL PUBLIC LICENSE
Version 2, June 1991
Copyright (C) 1989, 1991 Free Software Foundation, Inc.
59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
Everyone is permitted to copy and distribute verbatim copies
of this license document, but changing it is not allowed.
Preamble
The licenses for most software are designed to take away your
freedom to share and change it. By contrast, the GNU General Public
License is intended to guarantee your freedom to share and change free
software--to make sure the software is free for all its users. This
General Public License applies to most of the Free Software
Foundation's software and to any other program whose authors commit to
using it. (Some other Free Software Foundation software is covered by
the GNU Library General Public License instead.) You can apply it to
your programs, too.
When we speak of free software, we are referring to freedom, not
price. Our General Public Licenses are designed to make sure that you
have the freedom to distribute copies of free software (and charge for
this service if you wish), that you receive source code or can get it
if you want it, that you can change the software or use pieces of it
in new free programs; and that you know you can do these things.
To protect your rights, we need to make restrictions that forbid
anyone to deny you these rights or to ask you to surrender the rights.
These restrictions translate to certain responsibilities for you if you
distribute copies of the software, or if you modify it.
For example, if you distribute copies of such a program, whether
gratis or for a fee, you must give the recipients all the rights that
you have. You must make sure that they, too, receive or can get the
source code. And you must show them these terms so they know their
rights.
We protect your rights with two steps: (1) copyright the software, and
(2) offer you this license which gives you legal permission to copy,
distribute and/or modify the software.
Also, for each author's protection and ours, we want to make certain
that everyone understands that there is no warranty for this free
software. If the software is modified by someone else and passed on, we
want its recipients to know that what they have is not the original, so
that any problems introduced by others will not reflect on the original
authors' reputations.
Finally, any free program is threatened constantly by software
patents. We wish to avoid the danger that redistributors of a free
program will individually obtain patent licenses, in effect making the
program proprietary. To prevent this, we have made it clear that any
patent must be licensed for everyone's free use or not licensed at all.
The precise terms and conditions for copying, distribution and
modification follow.
GNU GENERAL PUBLIC LICENSE
TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
0. This License applies to any program or other work which contains
a notice placed by the copyright holder saying it may be distributed
under the terms of this General Public License. The "Program", below,
refers to any such program or work, and a "work based on the Program"
means either the Program or any derivative work under copyright law:
that is to say, a work containing the Program or a portion of it,
either verbatim or with modifications and/or translated into another
language. (Hereinafter, translation is included without limitation in
the term "modification".) Each licensee is addressed as "you".
Activities other than copying, distribution and modification are not
covered by this License; they are outside its scope. The act of
running the Program is not restricted, and the output from the Program
is covered only if its contents constitute a work based on the
Program (independent of having been made by running the Program).
Whether that is true depends on what the Program does.
1. You may copy and distribute verbatim copies of the Program's
source code as you receive it, in any medium, provided that you
conspicuously and appropriately publish on each copy an appropriate
copyright notice and disclaimer of warranty; keep intact all the
notices that refer to this License and to the absence of any warranty;
and give any other recipients of the Program a copy of this License
along with the Program.
You may charge a fee for the physical act of transferring a copy, and
you may at your option offer warranty protection in exchange for a fee.
2. You may modify your copy or copies of the Program or any portion
of it, thus forming a work based on the Program, and copy and
distribute such modifications or work under the terms of Section 1
above, provided that you also meet all of these conditions:
a) You must cause the modified files to carry prominent notices
stating that you changed the files and the date of any change.
b) You must cause any work that you distribute or publish, that in
whole or in part contains or is derived from the Program or any
part thereof, to be licensed as a whole at no charge to all third
parties under the terms of this License.
c) If the modified program normally reads commands interactively
when run, you must cause it, when started running for such
interactive use in the most ordinary way, to print or display an
announcement including an appropriate copyright notice and a
notice that there is no warranty (or else, saying that you provide
a warranty) and that users may redistribute the program under
these conditions, and telling the user how to view a copy of this
License. (Exception: if the Program itself is interactive but
does not normally print such an announcement, your work based on
the Program is not required to print an announcement.)
These requirements apply to the modified work as a whole. If
identifiable sections of that work are not derived from the Program,
and can be reasonably considered independent and separate works in
themselves, then this License, and its terms, do not apply to those
sections when you distribute them as separate works. But when you
distribute the same sections as part of a whole which is a work based
on the Program, the distribution of the whole must be on the terms of
this License, whose permissions for other licensees extend to the
entire whole, and thus to each and every part regardless of who wrote it.
Thus, it is not the intent of this section to claim rights or contest
your rights to work written entirely by you; rather, the intent is to
exercise the right to control the distribution of derivative or
collective works based on the Program.
In addition, mere aggregation of another work not based on the Program
with the Program (or with a work based on the Program) on a volume of
a storage or distribution medium does not bring the other work under
the scope of this License.
3. You may copy and distribute the Program (or a work based on it,
under Section 2) in object code or executable form under the terms of
Sections 1 and 2 above provided that you also do one of the following:
a) Accompany it with the complete corresponding machine-readable
source code, which must be distributed under the terms of Sections
1 and 2 above on a medium customarily used for software interchange; or,
b) Accompany it with a written offer, valid for at least three
years, to give any third party, for a charge no more than your
cost of physically performing source distribution, a complete
machine-readable copy of the corresponding source code, to be
distributed under the terms of Sections 1 and 2 above on a medium
customarily used for software interchange; or,
c) Accompany it with the information you received as to the offer
to distribute corresponding source code. (This alternative is
allowed only for noncommercial distribution and only if you
received the program in object code or executable form with such
an offer, in accord with Subsection b above.)
The source code for a work means the preferred form of the work for
making modifications to it. For an executable work, complete source
code means all the source code for all modules it contains, plus any
associated interface definition files, plus the scripts used to
control compilation and installation of the executable. However, as a
special exception, the source code distributed need not include
anything that is normally distributed (in either source or binary
form) with the major components (compiler, kernel, and so on) of the
operating system on which the executable runs, unless that component
itself accompanies the executable.
If distribution of executable or object code is made by offering
access to copy from a designated place, then offering equivalent
access to copy the source code from the same place counts as
distribution of the source code, even though third parties are not
compelled to copy the source along with the object code.
4. You may not copy, modify, sublicense, or distribute the Program
except as expressly provided under this License. Any attempt
otherwise to copy, modify, sublicense or distribute the Program is
void, and will automatically terminate your rights under this License.
However, parties who have received copies, or rights, from you under
this License will not have their licenses terminated so long as such
parties remain in full compliance.
5. You are not required to accept this License, since you have not
signed it. However, nothing else grants you permission to modify or
distribute the Program or its derivative works. These actions are
prohibited by law if you do not accept this License. Therefore, by
modifying or distributing the Program (or any work based on the
Program), you indicate your acceptance of this License to do so, and
all its terms and conditions for copying, distributing or modifying
the Program or works based on it.
6. Each time you redistribute the Program (or any work based on the
Program), the recipient automatically receives a license from the
original licensor to copy, distribute or modify the Program subject to
these terms and conditions. You may not impose any further
restrictions on the recipients' exercise of the rights granted herein.
You are not responsible for enforcing compliance by third parties to
this License.
7. If, as a consequence of a court judgment or allegation of patent
infringement or for any other reason (not limited to patent issues),
conditions are imposed on you (whether by court order, agreement or
otherwise) that contradict the conditions of this License, they do not
excuse you from the conditions of this License. If you cannot
distribute so as to satisfy simultaneously your obligations under this
License and any other pertinent obligations, then as a consequence you
may not distribute the Program at all. For example, if a patent
license would not permit royalty-free redistribution of the Program by
all those who receive copies directly or indirectly through you, then
the only way you could satisfy both it and this License would be to
refrain entirely from distribution of the Program.
If any portion of this section is held invalid or unenforceable under
any particular circumstance, the balance of the section is intended to
apply and the section as a whole is intended to apply in other
circumstances.
It is not the purpose of this section to induce you to infringe any
patents or other property right claims or to contest validity of any
such claims; this section has the sole purpose of protecting the
integrity of the free software distribution system, which is
implemented by public license practices. Many people have made
generous contributions to the wide range of software distributed
through that system in reliance on consistent application of that
system; it is up to the author/donor to decide if he or she is willing
to distribute software through any other system and a licensee cannot
impose that choice.
This section is intended to make thoroughly clear what is believed to
be a consequence of the rest of this License.
8. If the distribution and/or use of the Program is restricted in
certain countries either by patents or by copyrighted interfaces, the
original copyright holder who places the Program under this License
may add an explicit geographical distribution limitation excluding
those countries, so that distribution is permitted only in or among
countries not thus excluded. In such case, this License incorporates
the limitation as if written in the body of this License.
9. The Free Software Foundation may publish revised and/or new versions
of the General Public License from time to time. Such new versions will
be similar in spirit to the present version, but may differ in detail to
address new problems or concerns.
Each version is given a distinguishing version number. If the Program
specifies a version number of this License which applies to it and "any
later version", you have the option of following the terms and conditions
either of that version or of any later version published by the Free
Software Foundation. If the Program does not specify a version number of
this License, you may choose any version ever published by the Free Software
Foundation.
10. If you wish to incorporate parts of the Program into other free
programs whose distribution conditions are different, write to the author
to ask for permission. For software which is copyrighted by the Free
Software Foundation, write to the Free Software Foundation; we sometimes
make exceptions for this. Our decision will be guided by the two goals
of preserving the free status of all derivatives of our free software and
of promoting the sharing and reuse of software generally.
NO WARRANTY
11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN
OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS
TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE
PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
REPAIR OR CORRECTION.
12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
POSSIBILITY OF SUCH DAMAGES.
END OF TERMS AND CONDITIONS
How to Apply These Terms to Your New Programs
If you develop a new program, and you want it to be of the greatest
possible use to the public, the best way to achieve this is to make it
free software which everyone can redistribute and change under these terms.
To do so, attach the following notices to the program. It is safest
to attach them to the start of each source file to most effectively
convey the exclusion of warranty; and each file should have at least
the "copyright" line and a pointer to where the full notice is found.
<one line to give the program's name and a brief idea of what it does.>
Copyright (C) <year> <name of author>
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
Also add information on how to contact you by electronic and paper mail.
If the program is interactive, make it output a short notice like this
when it starts in an interactive mode:
Gnomovision version 69, Copyright (C) year name of author
Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
This is free software, and you are welcome to redistribute it
under certain conditions; type `show c' for details.
The hypothetical commands `show w' and `show c' should show the appropriate
parts of the General Public License. Of course, the commands you use may
be called something other than `show w' and `show c'; they could even be
mouse-clicks or menu items--whatever suits your program.
You should also get your employer (if you work as a programmer) or your
school, if any, to sign a "copyright disclaimer" for the program, if
necessary. Here is a sample; alter the names:
Yoyodyne, Inc., hereby disclaims all copyright interest in the program
`Gnomovision' (which makes passes at compilers) written by James Hacker.
<signature of Ty Coon>, 1 April 1989
Ty Coon, President of Vice
This General Public License does not permit incorporating your program into
proprietary programs. If your program is a subroutine library, you may
consider it more useful to permit linking proprietary applications with the
library. If this is what you want to do, use the GNU Library General
Public License instead of this License.

3
src/pbl/hierFooter.inc
View file

@ -1,3 +0,0 @@
<hr>
Copyright(C) 2003 Peter Graf, this software is distributed under the
<a href="http://www.gnu.org/">GNU</a> Lesser General Public License

4
src/pbl/hierHeader.inc
View file

@ -1,4 +0,0 @@
<center>
<H1>Documentation for PBL</H1>
The Program Base Library
</center>

3
src/pbl/indexFooter.inc
View file

@ -1,3 +0,0 @@
<hr>
Copyright(C) 2003 Peter Graf, this software is distributed under the
<a href="http://www.gnu.org/">GNU</a> Lesser General Public License

Some files were not shown because too many files have changed in this diff Show more