static inline
void check_free(alarm_handle_t h) {
if (h->live == FALSE &&
h->count == 0) {
record_free(h) ;
}
}
int dbf_scan_next(DBF_SCAN *scan)
{
DBF *dbf = scan->dbf;
COMPARE *compare = scan->compare;
RECORD *rec;
int next_match = -1;
DBUG_ENTER("dbf_scan_next");
while(1)
{
if(!(rec = dbf_read_next(dbf)))
{
DBUG_PRINT("info", ("DBF Scan: End of file reached."));
goto no_match;
}
if(!compare) goto match;
if(compare->func(dbf_record_field(rec, scan->key), scan->value))
{
DBUG_PRINT("info", ("DBF Scan: Found match at record %i, %s %s %s.",
dbf->position-1,
scan->key, compare->oper, scan->value));
goto match;
}
DBUG_PRINT("info", ("DBF Scan: No match at record %i.",
dbf->position-1));
}
match:
next_match = dbf->position-1;
record_free(rec);
no_match:
DBUG_RETURN(scan->last = next_match);
}
int main(int argc, char **argv)
{
FIXED *fixed;
RECORD *record;
DBUG_ENTER("main");
DBUG_PROCESS(argv[0]);
DBUG_PUSH("d:t");
if(!(fixed = fixed_init(0)))
{
fprintf(stderr, "Couldn't allocate FIXED\n");
exit(1);
}
fixed_options(fixed)->gap = 1;
fixed_file_def(fixed, usps_state, 36);
fixed_dump(fixed);
fixed_open(fixed, argv[1], 'r');
while(record = fixed_read_next(fixed))
{
record_dump(record);
record_free(record);
}
fixed_close(fixed);
fixed_free(fixed);
DBUG_RETURN(0);
}
void free_record(void *ptr)
{
record_free(ptr);
/* it is not an error if we do not find the ptr in our list; we only
* store the last N_RECORDS allocations
*/
free(ptr);
}
void *realloc_record(void *ptr, size_t size,
const char *file, const char *func, int line)
{
record_free(ptr);
ptr = realloc(ptr, size);
record_alloc(ptr, size, file, func, line);
return ptr;
}
void free(void *ptr) {
if (!ptr) return;
struct bucket_header *header = util_ptr_to_header(ptr);
if (header->type == BUCKET_TYPE_BLOB) {
blob_free(header);
} else {
size_t index = bucket_get_index(header, ptr);
record_free(header, index);
}
}
void refbuf_free_help(refbuf_t rbuf) {
refbuf_free_t rfree = rbuf->free ;
env_t env = rbuf->env ;
buf_t buf = rbuf->buf ;
assert(rbuf->count == 1) ;
assert(rbuf != &zero_rbuf) ;
record_free(rbuf) ;
nactive -- ;
if (rfree) {
rfree(env, buf) ;
} else {
sys_free(buf) ;
}
}
static void free_handler(state_t s) {
array_free(s->failed) ;
while (!priq_empty(s->priq)) {
item_t item ;
priq_get(s->priq, NULL, (void**)&item) ;
switch(item->type) {
case DROP_UP:
event_free(item->u.up.event) ;
unmarsh_free(item->u.up.abv) ;
break ;
case DROP_UPNM:
event_free(item->u.upnm.event) ;
break ;
OTHERWISE_ABORT() ;
}
record_free(item) ;
}
priq_free(s->priq) ;
}
void
database_free(database_t *database) {
size_t i;
if(!database) {
return;
}
for(i = 0; i < array_size(database->records); i++) {
record_free((record_t *) array_get(database->records, i));
}
for(i = 0; i < database->num_fields; i++) {
free(database->fields[i]);
}
free(database->filename);
free(database->fields);
array_free(database->records);
free(database);
}
void
test_record() {
record_t *record;
char fields[] = "ab\0abc\0abcd\0abcde\0ab\0c";
uint8_t *sizes;
size_t num_fields = 6;
sizes = malloc(sizeof(uint8_t) * 6);
sizes[0] = 3;
sizes[1] = 4;
sizes[2] = 5;
sizes[3] = 6;
sizes[4] = 3;
sizes[5] = 2;
record = record_new(num_fields, fields, sizes);
assert_string_equal("ab", record_get_field(record, 0));
assert_string_equal("abc", record_get_field(record, 1));
assert_string_equal("abcd", record_get_field(record, 2));
assert_string_equal("abcde", record_get_field(record, 3));
assert_string_equal("ab", record_get_field(record, 4));
assert_string_equal("c", record_get_field(record, 5));
assert_string_equal("ab", record_get_id(record));
assert_int_equal(2, record_field_size(record, 0));
assert_int_equal(3, record_field_size(record, 1));
assert_int_equal(4, record_field_size(record, 2));
assert_int_equal(5, record_field_size(record, 3));
assert_int_equal(2, record_field_size(record, 4));
assert_int_equal(1, record_field_size(record, 5));
record_free(record);
}
static void upnm_handler(state_t s, event_t e) {
switch(event_type(e)) {
case EVENT_FAIL:
assert(bool_array_super(event_failures(e), s->failed, s->vs->nmembers)) ;
bool_array_copy_into(s->failed, event_failures(e), s->vs->nmembers) ;
upnm(s, e) ;
break ;
case EVENT_INIT:
dnnm(s, event_timer_time(time_zero())) ;
upnm(s, e) ;
break ;
case EVENT_TIMER: {
etime_t time = event_time(e) ;
item_t item ;
while (priq_get_upto(s->priq, time, NULL, (void**)&item)) {
s->acct_delivered ++ ;
switch(item->type) {
case DROP_UP: {
rank_t origin = event_peer(item->u.up.event) ;
if (origin >= 0 &&
array_get(s->failed, origin)) {
up_free(item->u.up.event, item->u.up.abv) ;
} else {
up(s, item->u.up.event, item->u.up.abv) ;
}
} break ;
case DROP_UPNM:
upnm(s, item->u.upnm.event) ;
break ;
OTHERWISE_ABORT() ;
}
record_free(item) ;
}
if (time_ge(time, s->next_sweep)) {
if (!time_is_zero(s->next_sweep) &&
sys_random(5) == 1) {
rank_t i ;
bool_array_t suspects = bool_array_create_init(s->vs->nmembers, FALSE) ;
for(i=0;i<s->vs->nmembers;i++) {
if (i == s->ls->rank) {
continue ;
}
if (sys_random(4) == 0) {
array_set(suspects, i, TRUE) ;
}
}
if (bool_array_exists(suspects, s->vs->nmembers)) {
dnnm(s, event_suspect_reason_create(suspects, name)) ;
} else {
array_free(suspects) ;
}
}
#if 0
/* Suspicions are randomly generated every 0-8 seconds.
*/
s->next_sweep = time_add(time, time_of_usecs(sys_random(1<<23/*8M*/))) ;
#else
s->next_sweep = time_add(time, time_of_usecs(sys_random(1<<20/*1M*/))) ;
#endif
dnnm(s, event_timer_time(s->next_sweep)) ; /* request next sweep */
}
upnm(s, e) ;
} break ;
case EVENT_GOSSIP_EXT: {
/*endpt_id_t origin = NULL ;*/
etime_t delay ;
/*
let origin =
getExtender (function
| HealGos(_,(_,endpt),_,_) -> Some (Some endpt)
| SwitchGos(_,(_,endpt),_) -> Some (Some endpt)
| _ -> None
) None ev
in
*/
if (1 /*!origin*/) {
upnm(s, e) ;
} else if (s->partition) {
sys_abort() ;
} else if (!distrib(s, &delay)) {
event_free(e) ;
} else {
/* Deliver after a certain delay....
*/
etime_t when = time_add(alarm_gettime(s->alarm), delay) ;
item_t item = record_create(item_t, item) ;
item->type = DROP_UPNM ;
item->u.upnm.event = e ;
priq_add(s->priq, when, item) ;
dnnm(s, event_timer_time(when)) ;
}
} break ;
case EVENT_ACCOUNT:
log(("delivered=%d dropped=%d", s->acct_delivered, s->acct_dropped)) ;
upnm(s, e) ;
break ;
EVENT_DUMP_HANDLE() ;
default:
upnm(s, e) ;
break ;
}
}
int
main(int argc, const char *argv[])
{
int i;
Record* rec;
int code_return;
int tags_type = 0;
int db_type = 0;
/* zero global */
memset(&global, 0, sizeof(global));
i = 0;
global.tags_type_infos[i].name = "ctags";
global.tags_type_infos[i].func_read_one_record =
tags_ctags_read_one_record;
++ i;
#ifdef ENABLED_GCCXML
global.tags_type_infos[i].name = "gccxml";
global.tags_type_infos[i].func_read_one_record =
tags_gccxml_read_one_record;
#endif
global.db_type_infos[0].name = "sqlite3";
global.db_type_infos[0].func_initialize = db_sqlite3_initialize;
global.db_type_infos[0].func_write_one_record =
db_sqlite3_write_one_record;
global.db_type_infos[0].func_finalize = db_sqlite3_finalize;
/* default field name prefix is "tags2db_" */
global.output_db_object.field_prefix = "tags2db_";
/* parse argument */
{
bool tags_file_name_flag = false; /* indicates it's "-f" switch */
/* indicates tags file name has already been specified */
bool tags_file_name_already_specified_flag = false;
bool tags_type_flag = false;
bool db_type_flag = false;
bool db_field_prefix_flag = false; /* -p or --prefix */
for(i = 1; i < argc; ++i)
{
if(tags_file_name_flag)
{
tags_file_name_flag = false;
if(!strcmp(argv[i], "-"))
global.input_tag_object.input_tag_file = stdin;
else
{
global.input_tag_object.input_tag_file = fopen(
argv[i], "r");
if(!global.input_tag_object.input_tag_file)
{
perror("Unable to open the tag file");
exit(1);
}
}
tags_file_name_already_specified_flag = true;
}
else if(tags_type_flag)
{
int j;
tags_type_flag = false;
/*
* Check whether the specified tags type is available. If not
* available, print an error message and exit.
*/
tags_type = -1;
for(j = 0; j < TAGS_TYPE_INFO_COUNT; ++ j)
{
if(!strcmp(global.tags_type_infos[j].name, argv[i]))
{
tags_type = j;
break;
}
}
if(tags_type == -1)
{
fprintf(stderr, "Tags type \"");
fprintf(stderr, argv[i]);
fprintf(stderr, "\" is not available.\n");
exit(5);
}
}
else if(db_type_flag)
{
int j;
db_type_flag = false;
/*
* Check whether the specified tags type is available. If not
* available, print an error message and exit.
*/
db_type = -1;
for(j = 0; j < DB_TYPE_INFO_COUNT; ++ j)
{
if(!strcmp(global.db_type_infos[j].name, argv[i]))
{
db_type = j;
break;
}
}
if(db_type == -1)
{
fprintf(stderr, "Database type \"");
fprintf(stderr, argv[i]);
fprintf(stderr, "\" is not available.\n");
exit(6);
}
}
else if(db_field_prefix_flag)
{
db_field_prefix_flag = false;
global.output_db_object.field_prefix = argv[i];
}
else if(!strcmp(argv[i], "-t"))
tags_type_flag = true;
else if(!strcmp(argv[i], "-d"))
db_type_flag = true;
else if(!strcmp(argv[i], "-f"))
tags_file_name_flag = true;
else if((!strcmp(argv[i], "-p")) ||
(!strcmp(argv[i], "--prefix")))
{
db_field_prefix_flag = true;
}
else if((!strcmp(argv[i], "-h")) || (!strcmp(argv[i], "--help")))
{
print_help_string();
exit(0);
}
else if(!strcmp(argv[i], "--version"))
{
fprintf(stdout, get_version_string());
exit(0);
}
else if(strlen(argv[i]) > 0 && argv[i][0] == '-')
{
fprintf(stderr, "Uknown option \"");
fprintf(stderr, argv[i]);
fprintf(stderr, "\"\n");
exit(7);
}
else /* when no "-" siwtch is specified */
{
if(tags_file_name_already_specified_flag)
global.output_db_object.connection_string = strdup(
argv[i]);
else
{
-- i;
tags_file_name_flag = true;
}
}
}
}
if(!global.input_tag_object.input_tag_file)
{
fprintf(stderr, "Input tag file is not specified.\n");
exit(2);
}
if(!global.output_db_object.connection_string)
{
fprintf(stderr, "Out file path is not specified.\n");
exit(3);
}
if((code_return = (*global.db_type_infos[db_type].func_initialize) (
&global.output_db_object)) != 0)
{
fprintf(stderr, "Failed to initialize sqlite3: %d\n", code_return);
exit(4);
}
rec = (*global.tags_type_infos[tags_type].func_read_one_record) (
&global.input_tag_object);
while(rec)
{
if((code_return =
(*global.db_type_infos[db_type].func_write_one_record) (
&global.output_db_object, rec)) != 0)
{
fprintf(stderr, "Failed to write to sqlite3 database: %d\n",
code_return);
break;
}
record_free(rec);
rec = (*global.tags_type_infos[tags_type].func_read_one_record) (
&global.input_tag_object);
}
if((code_return = (*global.db_type_infos[db_type].func_finalize) (
&global.output_db_object)) != 0)
{
fprintf(stderr, "Failed to finalize the sqlite3 database: %d\n",
code_return);
}
/* close the tag file */
fclose(global.input_tag_object.input_tag_file);
return 0;
}
void iq_free(iq_t iq) {
iq_set_lo(iq, iq->hi) ;
sys_free(iq->arr) ;
record_free(iq) ;
}
void equeue_free(equeue_t q) {
sys_free(q->arr) ;
record_free(q) ;
}