/**
* gtags_next: return next record.
*
* @param[in] gtop #GTOP structure
* @return record
* @VAR{NULL} end of tag
*/
GTP *
gtags_next(GTOP *gtop)
{
if (gtop->flags & GTOP_PATH) {
if (gtop->path_index >= gtop->path_count)
return NULL;
gtop->gtp.path = gtop->path_array[gtop->path_index++];
return >op->gtp;
} else if (gtop->flags & GTOP_KEY) {
for (gtop->gtp.tag = dbop_next(gtop->dbop);
gtop->gtp.tag != NULL;
gtop->gtp.tag = dbop_next(gtop->dbop))
{
VIRTUAL_GRTAGS_GSYMS_PROCESSING(gtop);
break;
}
return gtop->gtp.tag ? >op->gtp : NULL;
} else {
/*
* End of segment.
* Reset resources and read new segment again.
*/
if (gtop->gtp_index >= gtop->gtp_count) {
varray_reset(gtop->vb);
pool_reset(gtop->segment_pool);
/* strhash_reset(gtop->path_hash); */
segment_read(gtop);
}
if (gtop->gtp_index >= gtop->gtp_count)
return NULL;
return >op->gtp_array[gtop->gtp_index++];
}
}
/**
* gtags_next: return next record.
*
* @param[in] gtop #GTOP structure
* @return record
* @VAR{NULL} end of tag
*/
GTP *
gtags_next(GTOP *gtop)
{
gtop->readcount++;
if (gtop->flags & GTOP_PATH) {
if (gtop->path_index >= gtop->path_count)
return NULL;
gtop->gtp.path = gtop->path_array[gtop->path_index++];
return >op->gtp;
} else if (gtop->flags & GTOP_KEY) {
gtop->gtp.tag = dbop_next(gtop->dbop);
again3:
for (; gtop->gtp.tag != NULL; gtop->gtp.tag = dbop_next(gtop->dbop))
{
VIRTUAL_GRTAGS_GSYMS_PROCESSING(gtop);
break;
}
if (gtop->gtp.tag == NULL) {
if (gtop->prefix && gtags_restart(gtop)) {
gtop->gtp.tag = dbop_first(gtop->dbop, gtop->key, gtop->preg, gtop->dbflags);
goto again3;
}
}
return gtop->gtp.tag ? >op->gtp : NULL;
} else {
/*
* End of segment.
* Reset resources and read new segment again.
*/
if (gtop->gtp_index >= gtop->gtp_count) {
varray_reset(gtop->vb);
pool_reset(gtop->segment_pool);
/* strhash_reset(gtop->path_hash); */
segment_read(gtop);
}
if (gtop->gtp_index >= gtop->gtp_count) {
if (gtop->prefix && gtags_restart(gtop)) {
gtop->gtp.tag = dbop_first(gtop->dbop, gtop->key, gtop->preg, gtop->dbflags);
if (gtop->gtp.tag == NULL)
return NULL;
dbop_unread(gtop->dbop);
segment_read(gtop);
} else
return NULL;
}
return >op->gtp_array[gtop->gtp_index++];
}
}
/**
* anchor_load: load anchor table
*
* @param[in] path path name
*/
void
anchor_load(const char *path)
{
int db, current_fid;
/* Get fid of the path */
{
const char *p = path2fid(path);
if (p == NULL)
die("anchor_load: internal error. file '%s' not found in GPATH.", path);
current_fid = atoi(p);
}
FIRST = LAST = 0;
end = CURRENT = NULL;
if (vb == NULL)
vb = varray_open(sizeof(struct anchor), 1000);
else
varray_reset(vb);
for (db = GTAGS; db < GTAGLIM; db++) {
XARGS *xp;
char *ctags_xid;
if ((xp = anchor_input[db]) == NULL)
continue;
/*
* Read from input stream until it reaches end of file
* or the line of another file appears.
*/
while ((ctags_xid = xargs_read(xp)) != NULL) {
SPLIT ptable;
struct anchor *a;
int type, fid;
const char *ctags_x = parse_xid(ctags_xid, NULL, &fid);
/*
* It is the following file.
*/
if (current_fid != fid) {
xargs_unread(xp);
break;
}
if (split(ctags_x, 4, &ptable) < 4) {
recover(&ptable);
die("too small number of parts in anchor_load().\n'%s'", ctags_x);
}
if (db == GTAGS) {
char *p = ptable.part[PART_LINE].start;
for (; *p && isspace((unsigned char)*p); p++)
;
if (!*p) {
recover(&ptable);
die("The output of parser is illegal.\n%s", ctags_x);
}
/*
* Function header is applied only to the anchor whoes type is 'D'.
* (D: function, M: macro, T: type)
*/
type = 'T';
if (*p == '#')
type = 'M';
else if (locatestring(p, "typedef", MATCH_AT_FIRST))
type = 'T';
else if ((p = locatestring(p, ptable.part[PART_TAG].start, MATCH_FIRST)) != NULL) {
/* skip a tag and the following blanks */
p += strlen(ptable.part[PART_TAG].start);
for (; *p && isspace((unsigned char)*p); p++)
;
if (*p == '(')
type = 'D';
}
} else if (db == GRTAGS)
type = 'R';
else
type = 'Y';
/* allocate an entry */
a = varray_append(vb);
a->lineno = atoi(ptable.part[PART_LNO].start);
a->type = type;
a->done = 0;
settag(a, ptable.part[PART_TAG].start);
recover(&ptable);
}
if (ctags_xid == NULL) {
xargs_close(anchor_input[db]);
anchor_input[db] = NULL;
}
}
if (vb->length == 0) {
table = NULL;
} else {
int i, used = vb->length;
/*
* Sort by lineno.
*/
table = varray_assign(vb, 0, 0);
qsort(table, used, sizeof(struct anchor), cmp);
/*
* Setup some lineno.
*/
for (i = 0; i < used; i++)
if (table[i].type == 'D')
break;
if (i < used)
FIRST = table[i].lineno;
for (i = used - 1; i >= 0; i--)
if (table[i].type == 'D')
break;
if (i >= 0)
LAST = table[i].lineno;
}
/*
* Setup loop range.
*/
start = table;
curp = NULL;
end = &table[vb->length];
/* anchor_dump(stderr, 0);*/
}
/**
* gtags_first: return first record
*
* @param[in] gtop #GTOP structure
* @param[in] pattern tag name <br>
* - may be regular expression
* - may be @VAR{NULL}
* @param[in] flags #GTOP_PREFIX: prefix read <br>
* #GTOP_KEY: read key only <br>
* #GTOP_PATH: read path only <br>
* #GTOP_NOREGEX: don't use regular expression. <br>
* #GTOP_IGNORECASE: ignore case distinction. <br>
* #GTOP_BASICREGEX: use basic regular expression. <br>
* #GTOP_NOSORT: don't sort
* @return record
*/
GTP *
gtags_first(GTOP *gtop, const char *pattern, int flags)
{
int dbflags = 0;
int regflags = 0;
char prefix[IDENTLEN];
static regex_t reg;
regex_t *preg = ®
const char *key = NULL;
const char *tagline;
/* Settlement for last time if any */
if (gtop->path_hash) {
strhash_close(gtop->path_hash);
gtop->path_hash = NULL;
}
if (gtop->path_array) {
free(gtop->path_array);
gtop->path_array = NULL;
}
gtop->flags = flags;
if (flags & GTOP_PREFIX && pattern != NULL)
dbflags |= DBOP_PREFIX;
if (flags & GTOP_KEY)
dbflags |= DBOP_KEY;
if (!(flags & GTOP_BASICREGEX))
regflags |= REG_EXTENDED;
if (flags & GTOP_IGNORECASE)
regflags |= REG_ICASE;
/*
* Get key and compiled regular expression for dbop_xxxx().
*/
if (flags & GTOP_NOREGEX) {
key = pattern;
preg = NULL;
} else if (pattern == NULL || !strcmp(pattern, ".*")) {
/*
* Since the regular expression '.*' matches to any record,
* we take sequential read method.
*/
key = NULL;
preg = NULL;
} else if (isregex(pattern) && regcomp(preg, pattern, regflags) == 0) {
const char *p;
/*
* If the pattern include '^' + some non regular expression
* characters like '^aaa[0-9]', we take prefix read method
* with the non regular expression part as the prefix.
*/
if (!(flags & GTOP_IGNORECASE) && *pattern == '^' && *(p = pattern + 1) && !isregexchar(*p)) {
int i = 0;
while (*p && !isregexchar(*p) && i < IDENTLEN)
prefix[i++] = *p++;
prefix[i] = '\0';
key = prefix;
dbflags |= DBOP_PREFIX;
} else {
key = NULL;
}
} else {
key = pattern;
preg = NULL;
}
/*
* If GTOP_PATH is set, at first, we collect all path names in a pool and
* sort them. gtags_first() and gtags_next() returns one of the pool.
*/
if (gtop->flags & GTOP_PATH) {
struct sh_entry *entry;
char *p;
const char *cp;
unsigned long i;
gtop->path_hash = strhash_open(HASHBUCKETS);
/*
* Pool path names.
*
* fid path name
* +--------------------------
* |100 ./aaa/a.c
* |105 ./aaa/b.c
* ...
*/
for (tagline = dbop_first(gtop->dbop, key, preg, dbflags);
tagline != NULL;
tagline = dbop_next(gtop->dbop))
{
VIRTUAL_GRTAGS_GSYMS_PROCESSING(gtop);
/* extract file id */
p = locatestring(tagline, " ", MATCH_FIRST);
if (p == NULL)
die("Illegal tag record. '%s'\n", tagline);
*p = '\0';
entry = strhash_assign(gtop->path_hash, tagline, 1);
/* new entry: get path name and set. */
if (entry->value == NULL) {
cp = gpath_fid2path(tagline, NULL);
if (cp == NULL)
die("GPATH is corrupted.(file id '%s' not found)", tagline);
entry->value = strhash_strdup(gtop->path_hash, cp, 0);
}
}
/*
* Sort path names.
*
* fid path name path_array (sort)
* +-------------------------- +---+
* |100 ./aaa/a.c <-------* |
* |105 ./aaa/b.c <-------* |
* ... ...
*/
gtop->path_array = (char **)check_malloc(gtop->path_hash->entries * sizeof(char *));
i = 0;
for (entry = strhash_first(gtop->path_hash); entry != NULL; entry = strhash_next(gtop->path_hash))
gtop->path_array[i++] = entry->value;
if (i != gtop->path_hash->entries)
die("Something is wrong. 'i = %lu, entries = %lu'" , i, gtop->path_hash->entries);
if (!(gtop->flags & GTOP_NOSORT))
qsort(gtop->path_array, gtop->path_hash->entries, sizeof(char *), compare_path);
gtop->path_count = gtop->path_hash->entries;
gtop->path_index = 0;
if (gtop->path_index >= gtop->path_count)
return NULL;
gtop->gtp.path = gtop->path_array[gtop->path_index++];
return >op->gtp;
} else if (gtop->flags & GTOP_KEY) {
for (gtop->gtp.tag = dbop_first(gtop->dbop, key, preg, dbflags);
gtop->gtp.tag != NULL;
gtop->gtp.tag = dbop_next(gtop->dbop))
{
VIRTUAL_GRTAGS_GSYMS_PROCESSING(gtop);
break;
}
return gtop->gtp.tag ? >op->gtp : NULL;
} else {
if (gtop->vb == NULL)
gtop->vb = varray_open(sizeof(GTP), 200);
else
varray_reset(gtop->vb);
if (gtop->segment_pool == NULL)
gtop->segment_pool = pool_open();
else
pool_reset(gtop->segment_pool);
if (gtop->path_hash == NULL)
gtop->path_hash = strhash_open(HASHBUCKETS);
else
strhash_reset(gtop->path_hash);
tagline = dbop_first(gtop->dbop, key, preg, dbflags);
if (tagline == NULL)
return NULL;
/*
* Dbop_next() wil read the same record again.
*/
dbop_unread(gtop->dbop);
/*
* Read a tag segment with sorting.
*/
segment_read(gtop);
return >op->gtp_array[gtop->gtp_index++];
}
}
/**
* gtags_first: return first record
*
* @param[in] gtop #GTOP structure
* @param[in] pattern tag name <br>
* - may be regular expression
* - may be @VAR{NULL}
* @param[in] flags #GTOP_PREFIX: prefix read <br>
* #GTOP_KEY: read key only <br>
* #GTOP_PATH: read path only <br>
* #GTOP_NOREGEX: don't use regular expression. <br>
* #GTOP_IGNORECASE: ignore case distinction. <br>
* #GTOP_BASICREGEX: use basic regular expression. <br>
* #GTOP_NOSORT: don't sort
* @return record
*/
GTP *
gtags_first(GTOP *gtop, const char *pattern, int flags)
{
int regflags = 0;
static regex_t reg;
const char *tagline;
STATIC_STRBUF(regex);
strbuf_clear(regex);
gtop->preg = ®
gtop->key = NULL;
gtop->prefix = NULL;
gtop->flags = flags;
gtop->dbflags = 0;
gtop->readcount = 1;
/* Settlement for last time if any */
if (gtop->path_hash) {
strhash_close(gtop->path_hash);
gtop->path_hash = NULL;
}
if (gtop->path_array) {
free(gtop->path_array);
gtop->path_array = NULL;
}
if (flags & GTOP_KEY)
gtop->dbflags |= DBOP_KEY;
if (!(flags & GTOP_BASICREGEX))
regflags |= REG_EXTENDED;
/*
* decide a read method
*/
if (pattern == NULL)
gtop->preg = NULL;
else if (pattern[0] == 0)
return NULL;
else if (!strcmp(pattern, ".*") || !strcmp(pattern, "^.*$") ||
!strcmp(pattern, "^") || !strcmp(pattern, "$") ||
!strcmp(pattern, "^.*") || !strcmp(pattern, ".*$")) {
/*
* Since these regular expressions match to any record,
* we take sequential read method.
*/
gtop->preg = NULL;
} else if (flags & GTOP_IGNORECASE) {
regflags |= REG_ICASE;
if (!isregex(pattern) || flags & GTOP_NOREGEX) {
gtop->prefix = get_prefix(pattern, flags);
if (gtop->openflags & GTAGS_DEBUG)
if (gtop->prefix != NULL)
fprintf(stderr, "Using prefix: %s\n", gtop->prefix);
if (gtop->prefix == NULL)
die("gtags_first: impossible (1).");
strbuf_putc(regex, '^');
strbuf_puts(regex, pattern);
if (!(flags & GTOP_PREFIX))
strbuf_putc(regex, '$');
} else if (*pattern == '^' && (gtop->prefix = get_prefix(pattern, flags)) != NULL) {
if (gtop->openflags & GTAGS_DEBUG)
fprintf(stderr, "Using prefix: %s\n", gtop->prefix);
strbuf_puts(regex, pattern);
} else {
strbuf_puts(regex, pattern);
}
} else {
if (!isregex(pattern) || flags & GTOP_NOREGEX) {
if (flags & GTOP_PREFIX)
gtop->dbflags |= DBOP_PREFIX;
gtop->key = pattern;
gtop->preg = NULL;
} else if (*pattern == '^' && (gtop->key = get_prefix(pattern, flags)) != NULL) {
if (gtop->openflags & GTAGS_DEBUG)
fprintf(stderr, "Using prefix: %s\n", gtop->key);
gtop->dbflags |= DBOP_PREFIX;
gtop->preg = NULL;
} else {
strbuf_puts(regex, pattern);
}
}
if (gtop->prefix) {
if (gtop->key)
die("gtags_first: impossible (2).");
gtop->key = gtop->prefix;
gtop->dbflags |= DBOP_PREFIX;
}
if (strbuf_getlen(regex) > 0) {
if (gtop->preg == NULL)
die("gtags_first: impossible (3).");
if (regcomp(gtop->preg, strbuf_value(regex), regflags) != 0)
die("invalid regular expression.");
}
/*
* If GTOP_PATH is set, at first, we collect all path names in a pool and
* sort them. gtags_first() and gtags_next() returns one of the pool.
*/
if (gtop->flags & GTOP_PATH) {
struct sh_entry *entry;
char *p;
const char *cp;
unsigned long i;
gtop->path_hash = strhash_open(HASHBUCKETS);
/*
* Pool path names.
*
* fid path name
* +--------------------------
* |100 ./aaa/a.c
* |105 ./aaa/b.c
* ...
*/
again0:
for (tagline = dbop_first(gtop->dbop, gtop->key, gtop->preg, gtop->dbflags);
tagline != NULL;
tagline = dbop_next(gtop->dbop))
{
VIRTUAL_GRTAGS_GSYMS_PROCESSING(gtop);
/* extract file id */
p = locatestring(tagline, " ", MATCH_FIRST);
if (p == NULL)
die("Invalid tag record. '%s'\n", tagline);
*p = '\0';
entry = strhash_assign(gtop->path_hash, tagline, 1);
/* new entry: get path name and set. */
if (entry->value == NULL) {
cp = gpath_fid2path(tagline, NULL);
if (cp == NULL)
die("GPATH is corrupted.(file id '%s' not found)", tagline);
entry->value = strhash_strdup(gtop->path_hash, cp, 0);
}
}
if (gtop->prefix && gtags_restart(gtop))
goto again0;
/*
* Sort path names.
*
* fid path name path_array (sort)
* +-------------------------- +---+
* |100 ./aaa/a.c <-------* |
* |105 ./aaa/b.c <-------* |
* ... ...
*/
gtop->path_array = (char **)check_malloc(gtop->path_hash->entries * sizeof(char *));
i = 0;
for (entry = strhash_first(gtop->path_hash); entry != NULL; entry = strhash_next(gtop->path_hash))
gtop->path_array[i++] = entry->value;
if (i != gtop->path_hash->entries)
die("Something is wrong. 'i = %lu, entries = %lu'" , i, gtop->path_hash->entries);
if (!(gtop->flags & GTOP_NOSORT))
qsort(gtop->path_array, gtop->path_hash->entries, sizeof(char *), compare_path);
gtop->path_count = gtop->path_hash->entries;
gtop->path_index = 0;
if (gtop->path_index >= gtop->path_count)
return NULL;
gtop->gtp.path = gtop->path_array[gtop->path_index++];
return >op->gtp;
} else if (gtop->flags & GTOP_KEY) {
again1:
for (gtop->gtp.tag = dbop_first(gtop->dbop, gtop->key, gtop->preg, gtop->dbflags);
gtop->gtp.tag != NULL;
gtop->gtp.tag = dbop_next(gtop->dbop))
{
VIRTUAL_GRTAGS_GSYMS_PROCESSING(gtop);
break;
}
if (gtop->gtp.tag == NULL) {
if (gtop->prefix && gtags_restart(gtop))
goto again1;
}
return gtop->gtp.tag ? >op->gtp : NULL;
} else {
if (gtop->vb == NULL)
gtop->vb = varray_open(sizeof(GTP), 200);
else
varray_reset(gtop->vb);
if (gtop->segment_pool == NULL)
gtop->segment_pool = pool_open();
else
pool_reset(gtop->segment_pool);
if (gtop->path_hash == NULL)
gtop->path_hash = strhash_open(HASHBUCKETS);
else
strhash_reset(gtop->path_hash);
again2:
tagline = dbop_first(gtop->dbop, gtop->key, gtop->preg, gtop->dbflags);
if (tagline == NULL) {
if (gtop->prefix && gtags_restart(gtop))
goto again2;
return NULL;
}
/*
* Dbop_next() wil read the same record again.
*/
dbop_unread(gtop->dbop);
/*
* Read a tag segment with sorting.
*/
segment_read(gtop);
return >op->gtp_array[gtop->gtp_index++];
}
}