boolvec * cntr_read(const char * filename, const char * cntrname,
int col1, int col2, int col3,
const char* delimiter, int skip_lines, int grow_by)
{
boolvec * res = create_boolvec();
const char * fname = find_first(filename);
while (fname) {
d_cntr * contour = _cntr_read(fname, cntrname,
col1, col2, col3, skip_lines,
grow_by, delimiter);
if (contour != NULL) {
surfit_cntrs->push_back(contour);
res->push_back(true);
} else
res->push_back(false);
fname = find_next();
}
find_close();
return res;
};
boolvec * area_load(const char * filename, const char * areaname)
{
boolvec * res = create_boolvec();
const char * fname = find_first(filename);
while (fname != NULL) {
d_area * area = _area_load(fname, areaname);
if (area) {
surfit_areas->push_back(area);
res->push_back(true);
} else {
res->push_back(false);
fname = find_next();
continue;
}
if (areaname == NULL)
{
char * name = get_name(fname);
area->setName( name );
sstuff_free_char(name);
}
fname = find_next();
}
find_close();
return res;
};
///////////////////////////////////////////
// deepest_node(bp *b,i64 s)
// returns the first node with the largest depth in the subtree of s
///////////////////////////////////////////
i64 deepest_node(bp *b,i64 s)
{
i64 t,m;
t = find_close(b,s);
m = rmq(b,s,t, OPT_MAX);
return m;
}
///////////////////////////////////////////
// is_ancestor(bp *b, i64 s, i64 t)
// returns 1 if s is an ancestor of t
// 0 otherwise
///////////////////////////////////////////
i64 is_ancestor(bp *b, i64 s, i64 t)
{
i64 v;
v = find_close(b,s);
if (s <= t && t <= v) return 1;
return 0;
}
///////////////////////////////////////////
// postorder_rank(bp *b,i64 s)
// returns the postorder (>= 1) of node s (s >= 0)
// -1 if s-th bit is not OP
///////////////////////////////////////////
i64 postorder_rank(bp *b,i64 s)
{
i64 t;
if (inspect(b,s) == CP) return -1;
t = find_close(b,s);
// return t+1 - darray_rank(b->da,t);
return rank_close(b,t);
}
///////////////////////////////////////////
// next_sibling(bp *b,i64 s)
// returns the next sibling of parent(s)
// -1 if s is the last child
//////////////////////////////////////////
i64 next_sibling(bp *b, i64 s)
{
i64 t;
t = find_close(b,s)+1;
if (t >= b->n) {
printf("next_sibling: error s=%d t=%d\n",(int)s,(int)t);
}
if (inspect(b,t) == CP) return -1;
return t;
}
///////////////////////////////////////////
// rightmost_leaf(bp *b, i64 s)
///////////////////////////////////////////
i64 rightmost_leaf(bp *b, i64 s)
{
i64 t;
if ((b->opt & OPT_LEAF) == 0) {
printf("leftmost_leaf: error!!! not supported\n");
return -1;
}
t = find_close(b,s);
return leaf_select(b,leaf_rank(b,t));
}
///////////////////////////////////////////
// leaf_size(bp *b, i64 s)
///////////////////////////////////////////
i64 leaf_size(bp *b, i64 s)
{
i64 t;
if ((b->opt & OPT_LEAF) == 0) {
printf("leaf_size: error!!! not supported\n");
return -1;
}
t = find_close(b,s);
return leaf_rank(b,t) - leaf_rank(b,s);
}
boolvec * area_load_shp(const char * filename, const char * areaname)
{
boolvec * res = create_boolvec();
const char * fname = find_first(filename);
while (fname) {
res->push_back(_area_load_shp(fname, areaname));
fname = find_next();
}
find_close();
return res;
};
boolvec * area_load_bln(const char * filename, const char * areaname)
{
boolvec * res = create_boolvec();
const char * fname = find_first(filename);
while (fname) {
d_area * area = _area_load_bln(fname, areaname);
if (area)
surfit_areas->push_back(area);
res->push_back( area != NULL );
fname = find_next();
}
find_close();
return res;
};
boolvec * cntr_load(const char * filename, const char * cntrname)
{
boolvec * res = create_boolvec();
const char * fname = find_first(filename);
while (fname) {
d_cntr * contour = _cntr_load(fname, cntrname);
if (contour) {
surfit_cntrs->push_back(contour);
res->push_back(true);
} else
res->push_back(false);
fname = find_next();
}
find_close();
return res;
};
boolvec * area_read(const char * filename, const char * areaname,
int col1, int col2,
const char* delimiter, int skip_lines, int grow_by)
{
boolvec * res = create_boolvec();
const char * fname = find_first(filename);
while (fname != NULL) {
d_area * area = _area_read(fname, areaname,
col1, col2, skip_lines,
grow_by, delimiter);
if (area != NULL)
surfit_areas->push_back(area);
else {
writelog(LOG_WARNING,"failed to read area from file %s", fname);
res->push_back(false);
fname = find_next();
continue;
}
if (areaname == NULL)
{
char * name = get_name(fname);
area->setName( name );
sstuff_free_char(name);
}
res->push_back(true);
fname = find_next();
}
find_close();
return res;
};
int ScanFile(HXCFLOPPYEMULATOR* floppycontext,struct Volume * adfvolume,char * folder,char * file)
{
long hfindfile;
filefoundinfo FindFileData;
int bbool;
int byte_written;
FILE * ftemp;
unsigned char tempbuffer[512];
struct File* adffile;
unsigned char * fullpath;//,*fileimg;
int size,filesize;
RETCODE rc;
hfindfile=find_first_file(folder,file, &FindFileData);
if(hfindfile!=-1)
{
bbool=TRUE;
while(hfindfile!=-1 && bbool)
{
if(FindFileData.isdirectory)
{
if(strcmp(".",FindFileData.filename)!=0 && strcmp("..",FindFileData.filename)!=0)
{
if(adfCountFreeBlocks(adfvolume)>4)
{
floppycontext->hxc_printf(MSG_INFO_1,"Adding directory %s",FindFileData.filename);
rc=adfCreateDir(adfvolume,adfvolume->curDirPtr,FindFileData.filename);
if(rc==RC_OK)
{
floppycontext->hxc_printf(MSG_INFO_1,"entering directory %s",FindFileData.filename);
rc=adfChangeDir(adfvolume, FindFileData.filename);
if(rc==RC_OK)
{
fullpath=malloc(strlen(FindFileData.filename)+strlen(folder)+2);
sprintf(fullpath,"%s\\%s",folder,FindFileData.filename);
if(ScanFile(floppycontext,adfvolume,fullpath,file))
{
adfParentDir(adfvolume);
free(fullpath);
return 1;
}
floppycontext->hxc_printf(MSG_INFO_1,"Leaving directory %s",FindFileData.filename);
free(fullpath);
adfParentDir( adfvolume);
}
else
{
floppycontext->hxc_printf(MSG_ERROR,"Cannot enter to the directory %s !",FindFileData.filename);
return 1;
}
}
else
{
floppycontext->hxc_printf(MSG_ERROR,"Cannot Add the directory %s !",FindFileData.filename);
return 1;
}
}
else
{
floppycontext->hxc_printf(MSG_ERROR,"Cannot Add a directory ! : no more free block!!!");
return 1;
}
}
}
else
{
if(adfCountFreeBlocks(adfvolume)>4)
{
floppycontext->hxc_printf(MSG_INFO_1,"Adding file %s, %dB",FindFileData.filename,FindFileData.size);
adffile = adfOpenFile(adfvolume, FindFileData.filename, "w");
if(adffile)
{
if(FindFileData.size)
{
fullpath=malloc(strlen(FindFileData.filename)+strlen(folder)+2);
sprintf(fullpath,"%s\\%s",folder,FindFileData.filename);
ftemp=fopen(fullpath,"rb");
if(ftemp)
{
fseek(ftemp,0,SEEK_END);
filesize=ftell(ftemp);
fseek(ftemp,0,SEEK_SET);
do
{
if(filesize>=512)
{
size=512;
}
else
{
size=filesize;
}
fread(&tempbuffer,size,1,ftemp);
byte_written=adfWriteFile(adffile, size, tempbuffer);
if((byte_written!=size) || (adfCountFreeBlocks(adfvolume)<2) )
{
floppycontext->hxc_printf(MSG_ERROR,"Error while writting the file %s. No more free block ?",FindFileData.filename);
adfCloseFile(adffile);
fclose(ftemp);
free(fullpath);
return 1;
}
filesize=filesize-512;
}while( (filesize>0) && (byte_written==size));
/*fileimg=(unsigned char*)malloc(filesize);
memset(fileimg,0,filesize);
fread(fileimg,filesize,1,ftemp);
adfWriteFile(adffile, filesize, fileimg);
free(fileimg);*/
adfCloseFile(adffile);
fclose(ftemp);
free(fullpath);
}
else
{
floppycontext->hxc_printf(MSG_ERROR,"Error : Cannot open %s !!!",fullpath);
free(fullpath);
return 1;
}
}
}
else
{
floppycontext->hxc_printf(MSG_ERROR,"Error : Cannot create %s, %dB!!!",FindFileData.filename,FindFileData.size);
return 1;
}
}
else
{
floppycontext->hxc_printf(MSG_ERROR,"Error : Cannot add a file : no more free block");
return 1;
}
}
bbool=find_next_file(hfindfile,folder,file,&FindFileData);
}
}
else printf("Error FindFirstFile\n");
find_close(hfindfile);
return 0;
}
///////////////////////////////////////////
// subtree_size(bp *b, i64 s)
// returns the number of nodes in the subtree of s
///////////////////////////////////////////
i64 subtree_size(bp *b, i64 s)
{
return (find_close(b,s) - s + 1) / 2;
}
int ScanFileAndAddToFAT(HXCFLOPPYEMULATOR* floppycontext,char * folder,char * file, char * fattable,char *entriestable,char *datatable,int parentcluster,FATCONFIG * fatconfig,int numberofcluster)
{
long hfindfile;
filefoundinfo FindFileData;
int bbool;
int tii;
FILE * ftemp;
char * newentry;
char * subnewentry;
char tempstr[256];
int lefttoread;
int fatclusternb;
unsigned char * fullpath;
fat_directory_entry *entry;
fat_directory_entry *subentry;
int i,j;
struct stat repstate;
struct tm * ts;
tii=0;
hfindfile=find_first_file(folder,file, &FindFileData);
if(hfindfile!=-1)
{
bbool=1;
while(hfindfile!=-1 && bbool)
{
if(FindFileData.isdirectory)
{
if(strcmp(".",FindFileData.filename)!=0 && strcmp("..",FindFileData.filename)!=0)
{
newentry=findfreeentry(entriestable);
entry=(fat_directory_entry *)newentry;
memset(entry->DIR_Name,0x20,8+3);
sprintf((char*)tempstr,"%s",FindFileData.filename);
floppycontext->hxc_printf(MSG_INFO_1,"Adding directory %s",FindFileData.filename);
strupper(tempstr);
if(strchr(tempstr,'.'))
{
memcpy(&entry->DIR_Name[8],strchr(tempstr,'.')+1,strlen(strchr(tempstr,'.')+1));
*strchr(tempstr,'.')=0;
}
memcpy(entry->DIR_Name,tempstr,strlen(tempstr));
entry->DIR_Attr=entry->DIR_Attr|0x10;
entry->DIR_FileSize=FindFileData.size;
fatclusternb=findfreecluster(fattable,numberofcluster);
if(fatclusternb==-1)
{
floppycontext->hxc_printf(MSG_ERROR,"Cannot add this directory ! : No more cluster free !");
find_close(hfindfile);
return 1;
}
memset(&datatable[(fatclusternb-2)*fatconfig->sectorsize*fatconfig->clustersize],0,fatconfig->sectorsize*fatconfig->clustersize);
entry->DIR_FstClusLO=fatclusternb;
//*( (unsigned short*) &newentry[0x1A])=fatclusternb;
setclusterptr(fattable,fatclusternb,0xFFF);
subnewentry=findfreeentry(&datatable[(fatclusternb-2)*fatconfig->sectorsize*fatconfig->clustersize]);
subentry=(fat_directory_entry *)subnewentry;
sprintf(subentry->DIR_Name,". ");
//memcpy(subnewentry,". ",strlen(". "));
subentry->DIR_Attr=0x10;
subentry->DIR_FstClusLO=fatclusternb;
subnewentry=findfreeentry(&datatable[(fatclusternb-2)*fatconfig->sectorsize*fatconfig->clustersize]);
subentry=(fat_directory_entry *)subnewentry;
sprintf(subentry->DIR_Name,".. ");
subentry->DIR_Attr=0x10;
subentry->DIR_FstClusLO=parentcluster;
//*( (unsigned short*) &subnewentry[0x1A])=parentcluster;
floppycontext->hxc_printf(MSG_INFO_1,"Entering directory %s",FindFileData.filename);
fullpath=malloc(strlen(FindFileData.filename)+strlen(folder)+2);
sprintf(fullpath,"%s\\%s",folder,FindFileData.filename);
if(ScanFileAndAddToFAT(floppycontext,fullpath,file,fattable,&datatable[(fatclusternb-2)*fatconfig->sectorsize*fatconfig->clustersize],datatable,fatclusternb,fatconfig,numberofcluster))
{
free(fullpath);
find_close(hfindfile);
return 1;
}
free(fullpath);
floppycontext->hxc_printf(MSG_INFO_1,"Leaving directory %s",FindFileData.filename);
}
}
else
{
floppycontext->hxc_printf(MSG_INFO_1,"Adding file %s, %dB",FindFileData.filename,FindFileData.size);
sprintf(tempstr,"%s",FindFileData.filename);
strupper(tempstr);
newentry=findfreeentry(entriestable);
entry=(fat_directory_entry *)newentry;
memset(entry->DIR_Name,0x20,8+3);
i=0;
while(tempstr[i] && (i<8) && tempstr[i]!='.')
{
if(tempstr[i]==' ')
{
newentry[i]='_';
}
else
{
newentry[i]=tempstr[i];
}
i++;
}
if(strchr(tempstr,'.'))
{
i=0;
while(tempstr[i]!='.')
{
i++;
}
j=0;
i++;
while(tempstr[i] && (j<3))
{
if(tempstr[i]==' ')
{
newentry[8+j]='_';
}
else
{
newentry[8+j]=tempstr[i];
}
i++;
j++;
}
memcpy(newentry+8,strchr(tempstr,'.')+1,strlen(strchr(tempstr,'.')+1));
*strchr(tempstr,'.')=0;
}
entry->DIR_FileSize=FindFileData.size;
if(FindFileData.size)
{
lefttoread=FindFileData.size;
fatclusternb=findfreecluster(fattable,numberofcluster);
memset(&datatable[(fatclusternb-2)*fatconfig->sectorsize*fatconfig->clustersize],0,fatconfig->sectorsize*fatconfig->clustersize);
if(fatclusternb==-1)
{
floppycontext->hxc_printf(MSG_ERROR,"Cannot add this file ! : No more cluster free !");
find_close(hfindfile);
return 1;
}
entry->DIR_FstClusLO=fatclusternb;
if(file)
{
fullpath=malloc(strlen(FindFileData.filename)+strlen(folder)+2);
sprintf(fullpath,"%s\\%s",folder,FindFileData.filename);
}
else
{
fullpath=malloc(strlen(folder)+1);
sprintf(fullpath,"%s",folder);
}
stat(fullpath,&repstate);
ts=localtime(&repstate.st_ctime);
if(ts)
{
entry->DIR_CrtDate= (((ts->tm_year-80) &0x7F)<<9) | ((ts->tm_mon+1 &0xF)<<5) | (ts->tm_mday &0x1F);
entry->DIR_CrtTime= ((ts->tm_hour&0x1F)<<11) | ((ts->tm_min &0x3F)<<5) | ((ts->tm_sec/2)&0x1F);
}
else
{
entry->DIR_CrtDate= 0;
entry->DIR_CrtTime= 0;
}
stat(fullpath,&repstate);
ts=localtime(&repstate.st_mtime);
if(ts)
{
entry->DIR_WrtDate= (((ts->tm_year-80) &0x7F)<<9) | ((ts->tm_mon+1 &0xF)<<5) | (ts->tm_mday &0x1F);
entry->DIR_WrtTime= ((ts->tm_hour&0x1F)<<11) | ((ts->tm_min &0x3F)<<5) | ((ts->tm_sec/2)&0x1F);
}
else
{
entry->DIR_WrtDate= 0;
entry->DIR_WrtTime= 0;
}
ftemp=fopen(fullpath,"rb");
if(ftemp)
{
do
{
fatclusternb=findfreecluster(fattable,numberofcluster);
if(fatclusternb==-1)
{
floppycontext->hxc_printf(MSG_ERROR,"Error while adding this file ! : No more cluster free !");
free(fullpath);
find_close(hfindfile);
fclose(ftemp);
return 1;
}
memset(&datatable[(fatclusternb-2)*fatconfig->sectorsize*fatconfig->clustersize],0x00,fatconfig->sectorsize*fatconfig->clustersize);
fread(&datatable[(fatclusternb-2)*fatconfig->sectorsize*fatconfig->clustersize],fatconfig->sectorsize*fatconfig->clustersize,1,ftemp);
setclusterptr(fattable,fatclusternb,0xFFF);
if(lefttoread>(fatconfig->sectorsize*fatconfig->clustersize))
{
setclusterptr(fattable,fatclusternb,findfreecluster(fattable,numberofcluster));
}
lefttoread=lefttoread-(fatconfig->sectorsize*fatconfig->clustersize);
}while(lefttoread>0);
fclose(ftemp);
}
else
{
floppycontext->hxc_printf(MSG_ERROR,"Error while adding this file ! : Access error !");
}
free(fullpath);
}
}
bbool=find_next_file(hfindfile,folder,file,&FindFileData);
}
}
else printf("Error FindFirstFile\n");
find_close(hfindfile);
return 0;
}
/*
* createtags: create tags file
*
* i) dbpath dbpath directory
* i) root root directory of source tree
*/
void
createtags(const char *dbpath, const char *root)
{
STATISTICS_TIME *tim;
STRBUF *sb = strbuf_open(0);
struct put_func_data data;
int openflags, flags, seqno;
const char *path;
tim = statistics_time_start("Time of creating %s and %s.", dbname(GTAGS), dbname(GRTAGS));
if (vflag)
fprintf(stderr, "[%s] Creating '%s' and '%s'.\n", now(), dbname(GTAGS), dbname(GRTAGS));
openflags = cflag ? GTAGS_COMPACT : 0;
data.gtop[GTAGS] = gtags_open(dbpath, root, GTAGS, GTAGS_CREATE, openflags);
data.gtop[GTAGS]->flags = 0;
if (extractmethod)
data.gtop[GTAGS]->flags |= GTAGS_EXTRACTMETHOD;
data.gtop[GRTAGS] = gtags_open(dbpath, root, GRTAGS, GTAGS_CREATE, openflags);
data.gtop[GRTAGS]->flags = data.gtop[GTAGS]->flags;
flags = 0;
if (debug)
flags |= PARSER_DEBUG;
if (wflag)
flags |= PARSER_WARNING;
/*
* Add tags to GTAGS and GRTAGS.
*/
if (file_list)
find_open_filelist(file_list, root);
else
find_open(NULL);
seqno = 0;
while ((path = find_read()) != NULL) {
if (*path == ' ') {
path++;
if (!test("b", path))
gpath_put(path, GPATH_OTHER);
continue;
}
gpath_put(path, GPATH_SOURCE);
data.fid = gpath_path2fid(path, NULL);
if (data.fid == NULL)
die("GPATH is corrupted.('%s' not found)", path);
seqno++;
if (vflag)
fprintf(stderr, " [%d] extracting tags of %s\n", seqno, path + 2);
if (debug)
fprintf(stderr, "[%s]\n", path + 2);
parse_file(path, flags, put_syms, &data);
gtags_flush(data.gtop[GTAGS], data.fid);
gtags_flush(data.gtop[GRTAGS], data.fid);
}
total = seqno;
parser_exit();
find_close();
statistics_time_end(tim);
tim = statistics_time_start("Time of flushing B-tree cache");
gtags_close(data.gtop[GTAGS]);
gtags_close(data.gtop[GRTAGS]);
statistics_time_end(tim);
strbuf_reset(sb);
if (getconfs("GTAGS_extra", sb)) {
tim = statistics_time_start("Time of executing GTAGS_extra command");
if (system(strbuf_value(sb)))
fprintf(stderr, "GTAGS_extra command failed: %s\n", strbuf_value(sb));
statistics_time_end(tim);
}
strbuf_reset(sb);
if (getconfs("GRTAGS_extra", sb)) {
tim = statistics_time_start("Time of executing GRTAGS_extra command");
if (system(strbuf_value(sb)))
fprintf(stderr, "GRTAGS_extra command failed: %s\n", strbuf_value(sb));
statistics_time_end(tim);
}
strbuf_close(sb);
}
/*
* incremental: incremental update
*
* i) dbpath dbpath directory
* i) root root directory of source tree
* r) 0: not updated, 1: updated
*/
int
incremental(const char *dbpath, const char *root)
{
STATISTICS_TIME *tim;
struct stat statp;
STRBUF *addlist = strbuf_open(0);
STRBUF *deletelist = strbuf_open(0);
STRBUF *addlist_other = strbuf_open(0);
IDSET *deleteset, *findset;
int updated = 0;
const char *path;
unsigned int id, limit;
tim = statistics_time_start("Time of inspecting %s and %s.", dbname(GTAGS), dbname(GRTAGS));
if (vflag) {
fprintf(stderr, " Tag found in '%s'.\n", dbpath);
fprintf(stderr, " Incremental updating.\n");
}
/*
* get modified time of GTAGS.
*/
path = makepath(dbpath, dbname(GTAGS), NULL);
if (gpath_open(dbpath, 0) < 0)
die("GPATH not found.");
/*
* deleteset:
* The list of the path name which should be deleted from GPATH.
* findset:
* The list of the path name which exists in the current project.
* A project is limited by the --file option.
*/
deleteset = idset_open(gpath_nextkey());
findset = idset_open(gpath_nextkey());
total = 0;
/*
* Make add list and delete list for update.
*/
if (single_update) {
int type;
const char *fid = gpath_path2fid(single_update, &type);
/*
* The --single-update=file supports only updating.
* If it is new file, this option is ignored, and the processing is
* automatically switched to the normal procedure.
*/
if (fid == NULL) {
if (vflag)
fprintf(stderr, " --single-update option ignored, because '%s' is new file.\n", single_update);
goto normal_update;
}
/*
* If type != GPATH_SOURCE then we have nothing to do, and you will see
* a message 'Global databases are up to date.'.
*/
if (type == GPATH_SOURCE) {
strbuf_puts0(addlist, single_update);
idset_add(deleteset, atoi(fid));
total++;
}
} else {
normal_update:
if (file_list)
find_open_filelist(file_list, root);
else
find_open(NULL);
while ((path = find_read()) != NULL) {
const char *fid;
int n_fid = 0;
int other = 0;
/* a blank at the head of path means 'NOT SOURCE'. */
if (*path == ' ') {
if (test("b", ++path))
continue;
other = 1;
}
if (stat(path, &statp) < 0)
die("stat failed '%s'.", path);
fid = gpath_path2fid(path, NULL);
if (fid) {
n_fid = atoi(fid);
idset_add(findset, n_fid);
}
if (other) {
if (fid == NULL)
strbuf_puts0(addlist_other, path);
} else {
if (fid == NULL) {
strbuf_puts0(addlist, path);
total++;
} else if (gpath_mtime(NULL, fid) < statp.st_mtime) {
if (uflag) {
printf("%s\n", path);
} else {
strbuf_puts0(addlist, path);
total++;
idset_add(deleteset, n_fid);
}
}
}
}
find_close();
/*
* make delete list.
*/
if (remove_lost) {
limit = gpath_nextkey();
} else {
limit = 0;
}
for (id = 1; id < limit; id++) {
char fid[MAXFIDLEN];
int type;
snprintf(fid, sizeof(fid), "%d", id);
/*
* This is a hole of GPATH. The hole increases if the deletion
* and the addition are repeated.
*/
if ((path = gpath_fid2path(fid, &type)) == NULL)
continue;
/*
* The file which does not exist in the findset is treated
* assuming that it does not exist in the file system.
*/
if (type == GPATH_OTHER) {
if (!idset_contains(findset, id) || !test("f", path) || test("b", path))
strbuf_puts0(deletelist, path);
} else {
if (!idset_contains(findset, id) || !test("f", path)) {
strbuf_puts0(deletelist, path);
idset_add(deleteset, id);
}
}
}
}
gpath_close();
statistics_time_end(tim);
/*
* execute updating.
*/
if ((!idset_empty(deleteset) || strbuf_getlen(addlist) > 0) ||
(strbuf_getlen(deletelist) + strbuf_getlen(addlist_other) > 0))
{
int db;
updated = 1;
tim = statistics_time_start("Time of updating %s and %s.", dbname(GTAGS), dbname(GRTAGS));
if (!idset_empty(deleteset) || strbuf_getlen(addlist) > 0)
updatetags(dbpath, root, deleteset, addlist);
if (strbuf_getlen(deletelist) + strbuf_getlen(addlist_other) > 0) {
const char *start, *end, *p;
if (vflag)
fprintf(stderr, "[%s] Updating '%s'.\n", now(), dbname(GPATH));
gpath_open(dbpath, 2);
if (strbuf_getlen(deletelist) > 0) {
start = strbuf_value(deletelist);
end = start + strbuf_getlen(deletelist);
for (p = start; p < end; p += strlen(p) + 1)
gpath_delete(p);
}
if (strbuf_getlen(addlist_other) > 0) {
start = strbuf_value(addlist_other);
end = start + strbuf_getlen(addlist_other);
for (p = start; p < end; p += strlen(p) + 1)
gpath_put(p, GPATH_OTHER);
}
gpath_close();
}
/*
* Update modification time of tag files
* because they may have no definitions.
*/
for (db = GTAGS; db < GTAGLIM; db++)
utime(makepath(dbpath, dbname(db), NULL), NULL);
statistics_time_end(tim);
}
if (vflag) {
if (updated)
fprintf(stderr, " Global databases have been modified.\n");
else
fprintf(stderr, " Global databases are up to date.\n");
fprintf(stderr, "[%s] Done.\n", now());
}
strbuf_close(addlist);
strbuf_close(deletelist);
strbuf_close(addlist_other);
idset_close(deleteset);
idset_close(findset);
return updated;
}
