📄 db_main.c
字号:
c -= fhdr->fh_rec_size;
}
break;
#endif
#ifdef RAN
case DB_RANDOM:
c = buf->buf_data + sizeof(struct db_random_uhdr);
for (cnt=0; cnt < fhdr->fh_recs_per_blk; cnt++)
{ *c = DB_FREE;
c += fhdr->fh_rec_size;
}
if (buf->buf_cur_blk <= fhdr->fh_base_size)
{ ran = (RANDOM_HDR) buf->buf_data;
ran->ran_stat = DB_INUSE;
ran->ran_next = 0;
ran->ran_rec_cnt = 0;
}
else
{ fre = (FREE_REC) buf->buf_data;
fre->fre_stat = DB_FREE;
fre->fre_next = fhdr->fh_next_avail;
fhdr->fh_next_avail = buf->buf_cur_blk;
}
break;
#endif
#ifdef IDX
case DB_INDEX:
fre = (FREE_REC) buf->buf_data;
fre->fre_stat = DB_FREE;
fre->fre_next = fhdr->fh_next_avail;
fhdr->fh_next_avail = buf->buf_cur_blk;
break;
#endif
}
db_put_blk(df,df->df_buf);
db_put_blk(df,df->df_fhdr);
}
/*
* db_get_next_avail - Get Next Available Block
*/
void db_get_next_avail(df, buf)
DATA_FILE df;
BUFFER buf;
{
FILE_HDR fh;
FREE_REC fre;
RANDOM_HDR rhdr;
INDEX_HDR ihdr;
ulong blk;
ushort rec;
char *rbuf;
db_error = 0;
fh = (FILE_HDR) df->df_fhdr->buf_data;
if (!fh->fh_next_avail)
{ db_extend(df, buf);
if (db_error) return;
}
if (fh->fh_file_type == DB_SEQ)
{ blk = fh->fh_next_avail / fh->fh_recs_per_blk;
rec = fh->fh_next_avail % fh->fh_recs_per_blk;
if (rec==0)
rec = fh->fh_recs_per_blk;
else
blk++;
}
else
{ blk = fh->fh_next_avail;
rec = 1;
}
db_get_blk(df, blk, buf);
if (db_error) return;
buf->buf_rec_inx = rec;
rbuf = buf->buf_data + (rec - 1) * fh->fh_rec_size;
fre = (FREE_REC) rbuf;
if (fre->fre_stat != DB_FREE)
{ db_error = DB_INVALID_FREE;
return;
}
fre->fre_stat = DB_INUSE;
fh->fh_next_avail = fre->fre_next;
if (fh->fh_file_type == DB_INDEX)
if (!fh->fh_root_ptr)
fh->fh_root_ptr = blk;
switch (fh->fh_file_type)
{
#ifdef SEQ
case DB_SEQ:
break;
#endif
#ifdef RAN
case DB_RANDOM:
rhdr = (RANDOM_HDR) rbuf;
rhdr->ran_next = 0;
rhdr->ran_rec_cnt = 0;
break;
#endif
#ifdef IDX
case DB_INDEX:
ihdr = (INDEX_HDR) rbuf;
ihdr->idx_parent = 0;
ihdr->idx_rec_cnt = 0;
break;
#endif
}
}
/*
* db_free_rec - Free a deleted record
*/
void db_free_rec(df, buf)
DATA_FILE df;
BUFFER buf;
{
FILE_HDR fh;
FREE_REC fre;
VAR_REC var;
db_error = 0;
fh = (FILE_HDR) df->df_fhdr->buf_data;
switch (fh->fh_file_type)
{
#ifdef SEQ
case DB_SEQ:
fre = (FREE_REC) (buf->buf_data
+ (buf->buf_rec_inx - 1) * fh->fh_rec_size);
memset(fre, 0, fh->fh_rec_size);
fre->fre_stat = DB_FREE;
fre->fre_next = fh->fh_next_avail;
fh->fh_next_avail = (long) (buf->buf_cur_blk - 1)
* fh->fh_recs_per_blk + buf->buf_rec_inx;
break;
#endif
#ifdef RAN
case DB_RANDOM:
fre = (FREE_REC) buf->buf_data;
fre->fre_stat = DB_FREE;
fre->fre_next = fh->fh_next_avail;
fh->fh_next_avail = buf->buf_cur_blk;
break;
#endif
#ifdef IDX
case DB_INDEX:
fre = (FREE_REC) buf->buf_data;
memset(fre, 0, fh->fh_block_size);
fre->fre_stat = DB_FREE;
fre->fre_next = fh->fh_next_avail;
fh->fh_next_avail = buf->buf_cur_blk;
break;
#endif
#ifdef VAR
case DB_VAR:
var = (VAR_REC) buf->buf_data;
var->var_stat = DB_FREE;
memset(var->var_data, 0 , var->var_dsize);
break;
#endif
}
db_put_blk(df, buf);
if (db_error) return;
}
/*
* db_get_blk - Get a Block from a Data File
*/
void db_get_blk(df,blk,buf)
DATA_FILE df;
long blk;
BUFFER buf;
{
FILE_HDR fhdr;
VAR_REC var;
long psn, lseek();
short cnt;
db_error = 0;
if (!df)
{ db_error = DB_FILE_NOT_OPEN;
return;
}
if (!df->df_stat & DB_OPEN)
{ db_error = DB_FILE_NOT_OPEN;
return;
}
if (!buf)
{ db_error = DB_BUFFER_ERROR;
return;
}
fhdr = (FILE_HDR) df->df_fhdr->buf_data;
if (blk == 0)
{ psn = 0;
cnt = buf->buf_size;
}
else
if (fhdr->fh_file_type == DB_VAR)
{ psn = blk;
if (psn >= DB_FILE_HDR_SIZE)
cnt = buf->buf_size;
else
{ cnt = buf->buf_size - (DB_FILE_HDR_SIZE - psn);
psn = DB_FILE_HDR_SIZE;
blk = DB_FILE_HDR_SIZE;
if (cnt <= 0)
{ db_error = DB_INVALID_BLOCK;
return;
}
}
}
else
{ psn = DB_FILE_HDR_SIZE + (blk-1) * (long)fhdr->fh_block_size;
cnt = buf->buf_size;
}
buf->buf_cur_blk = 0;
buf->buf_cur_size = 0;
buf->buf_rec_inx = 0;
if (lseek(df->df_fd, psn, 0) < 0)
{ db_error = DB_INVALID_BLOCK;
return;
}
cnt = read(df->df_fd, buf->buf_data, cnt);
if (cnt < 0)
{ db_error = DB_READ_ERROR;
return;
}
if (cnt == 0)
{ db_error = DB_END_OF_FILE;
return;
}
buf->buf_cur_blk = blk;
buf->buf_cur_size = cnt;
}
/*
* db_put_blk - Put a Block out to a Data File
*/
void db_put_blk(df,buf)
DATA_FILE df;
BUFFER buf;
{
FILE_HDR fhdr;
VAR_REC var;
long psn, lseek();
int cnt;
db_error = 0;
if (!df)
{ db_error = DB_FILE_NOT_OPEN;
return;
}
if (!df->df_stat & DB_OPEN)
{ db_error = DB_FILE_NOT_OPEN;
return;
}
if (!buf)
{ db_error = DB_BUFFER_ERROR;
return;
}
if (buf->buf_cur_size == 0)
{ db_error = DB_INVALID_BLK_SIZE;
return;
}
fhdr = (FILE_HDR) df->df_fhdr->buf_data;
if (buf->buf_cur_blk == 0)
psn = 0;
else
if (fhdr->fh_file_type == DB_VAR)
{ psn = buf->buf_cur_blk;
if (psn < DB_FILE_HDR_SIZE)
{ db_error = DB_INVALID_BLOCK;
return;
}
}
else
psn = DB_FILE_HDR_SIZE
+ (buf->buf_cur_blk - 1) * (long)fhdr->fh_block_size;
if (lseek(df->df_fd, psn, 0) < 0)
{ db_error = DB_INVALID_BLOCK;
return;
}
cnt = write(df->df_fd, buf->buf_data, buf->buf_cur_size);
if (cnt != buf->buf_cur_size)
{ db_error = DB_WRITE_ERROR;
return;
}
}
/*
* db_alloc_buf - Get a Buffer
*/
BUFFER db_alloc_buf(size)
int size;
{
BUFFER buf;
char *calloc();
buf = (BUFFER) calloc(1, sizeof(struct db_data_buf));
if (!buf)
{ db_error = DB_ALLOC_ERROR;
return(NULL);
}
if (size)
{ buf->buf_size = size;
buf->buf_data = (char *) calloc(1, size);
if (!buf->buf_data)
{ db_error = DB_ALLOC_ERROR;
free(buf);
return(NULL);
}
}
return(buf);
}
/*
* db_free_buf - Free a Buffer
*/
BUFFER db_free_buf(buf)
BUFFER buf;
{
BUFFER prev,next;
if (!buf) return(NULL);
prev = buf->buf_prev;
next = buf->buf_next;
if (prev) prev->buf_next = buf->buf_next;
if (next) next->buf_prev = buf->buf_prev;
if (buf->buf_data) free(buf->buf_data);
free(buf);
return(next);
}
/*
* db_free_df - Free all dynamic structures for a Data File
*/
void db_free_df(df)
DATA_FILE df;
{
if (!df) return;
if (df->df_fhdr)
db_free_buf(df->df_fhdr);
while (df->df_buf)
df->df_buf = db_free_buf(df->df_buf);
if (df->df_tmp)
db_free_buf(df->df_tmp);
if (df->df_aux)
db_free_buf(df->df_aux);
free(df);
return;
}
/*
* db_error_msg - Return pointer to error message text
*/
static char *db_error_msgs[] =
{"DB-No error", /* 0 */
"DB-Data File Not Found", /* 1 */
"DB-Read Error", /* 2 */
"DB-End Of File", /* 3 */
"DB-Write Error", /* 4 */
"DB-Data File Not Created", /* 5 */
"DB-Data File Not Open", /* 6 */
"DB-Invalid Block", /* 7 */
"DB-Buffer Error", /* 8 */
"DB-No Current Record", /* 9 */
"DB-Record Deleted", /* 10 */
"DB-Free List Error", /* 11 */
"DB-Invalid Block Size", /* 12 */
"DB-Index File Corrupted", /* 13 */
"DB-Record Not Found", /* 14 */
"DB-Duplicate Key", /* 15 */
"DB-Invalid Request", /* 16 */
"DB-Random File Corrupted", /* 17 */
"DB-Invalid File Header", /* 18 */
"DB-File Version Mismatch", /* 19 */
"DB-Invalid Link Descriptor", /* 20 */
"DB-Linked List Corrupted", /* 21 */
"DB-Invalid File Type", /* 22 */
"DB-Invalid File Option", /* 23 */
"DB-Can't Allocate Memory", /* 24 */
"DB-Var File Rec Size Error", /* 25 */
"DB-Var File Check Sum Error",/* 26 */
"DB-Feature Unavailable", /* 27 */
"DB-Invalid Dictionary", /* 28 */
"DB-Invalid Name", /* 29 */
"DB-Invalid Error #", /* 30 */
""};
char *db_error_msg(error)
int error;
{
if (error < 0 || error > DB_LAST_ERROR)
error = DB_INVALID_ERROR;
return(db_error_msgs[error]);
}
/*
* memcpy - copy a block of memory taking care not to overlap
*/
void *memcpy(dst, src, cnt)
char *dst, *src;
int cnt;
{
char *s, *d;
if (dst > src && dst < src+cnt)
{ s = src + cnt - 1;
d = dst + cnt - 1;
while (cnt--) *d-- = *s--;
}
else
{ s = src;
d = dst;
while (cnt--) *d++ = *s++;
}
return(dst);
}
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -