/*
* makedefineindex: make definition index (including alphabetic index)
*
* @param[in] file definition index file
* @param[in] total definitions total
* @param[out] defines @defines
* Globals used (input):
* tag cache XXX: should this be global output, not input?
*/
int
makedefineindex(const char *file, int total, STRBUF *defines)
{
int count = 0;
int alpha_count = 0;
FILEOP *fileop_MAP = NULL, *fileop_DEFINES, *fileop_ALPHA = NULL;
FILE *MAP = NULL;
FILE *DEFINES, *STDOUT, *TAGS, *ALPHA = NULL;
STRBUF *sb = strbuf_open(0);
STRBUF *url = strbuf_open(0);
/* Index link */
const char *target = (Fflag) ? "mains" : "_top";
const char *indexlink;
const char *index_string = "Index Page";
char command[1024], buf[1024], alpha[32], alpha_f[32], *_;
if (!aflag && !Fflag)
indexlink = "mains";
else if (Fflag)
indexlink = "../defines";
else
indexlink = "../mains";
if (map_file) {
fileop_MAP = open_output_file(makepath(distpath, "MAP", NULL), 0);
MAP = get_descripter(fileop_MAP);
}
fileop_DEFINES = open_output_file(makepath(distpath, file, NULL), 0);
DEFINES = get_descripter(fileop_DEFINES);
fputs_nl(gen_page_begin(title_define_index, TOPDIR), DEFINES);
fputs_nl(body_begin, DEFINES);
fputs(header_begin, DEFINES);
if (Fflag)
fputs(gen_href_begin(NULL, "defines", normal_suffix, NULL), DEFINES);
fputs(title_define_index, DEFINES);
if (Fflag)
fputs(gen_href_end(), DEFINES);
fputs_nl(header_end, DEFINES);
if (!aflag && !Fflag) {
fputs(gen_href_begin_with_title(NULL, indexlink, normal_suffix, NULL, index_string), DEFINES);
if (Iflag)
fputs(gen_image(CURRENT, back_icon, ".."), DEFINES);
else
fputs("[..]", DEFINES);
fputs_nl(gen_href_end(), DEFINES);
}
if (!aflag) {
if (!no_order_list)
fputs_nl(list_begin, DEFINES);
}
/*
* map DEFINES to STDOUT.
*/
STDOUT = DEFINES;
snprintf(command, sizeof(command), PQUOTE "%s -c" PQUOTE, quote_shell(global_path));
if ((TAGS = popen(command, "r")) == NULL)
die("cannot execute '%s'.", command);
alpha[0] = '\0';
while ((_ = strbuf_fgets(sb, TAGS, STRBUF_NOCRLF)) != NULL) {
const char *tag, *line;
char guide[1024], url_for_map[1024];
count++;
tag = _;
message(" [%d/%d] adding %s", count, total, tag);
if (aflag && (alpha[0] == '\0' || !locatestring(tag, alpha, MATCH_AT_FIRST))) {
const char *msg = (alpha_count == 1) ? "definition" : "definitions";
int c;
if (alpha[0]) {
char tmp[128];
snprintf(tmp, sizeof(tmp), "%d %s", alpha_count, msg);
strbuf_puts(defines, gen_href_begin_with_title("defines", alpha_f, HTML, NULL, tmp));
strbuf_sprintf(defines, "[%s]", alpha);
strbuf_puts_nl(defines, gen_href_end());
alpha_count = 0;
if (!no_order_list)
fputs_nl(list_end, ALPHA);
else
fputs_nl(br, ALPHA);
fputs(gen_href_begin_with_title(NULL, indexlink, normal_suffix, NULL, index_string), ALPHA);
if (Iflag)
fputs(gen_image(PARENT, back_icon, ".."), ALPHA);
else
fputs("[..]", ALPHA);
fputs_nl(gen_href_end(), ALPHA);
fputs_nl(body_end, ALPHA);
fputs_nl(gen_page_end(), ALPHA);
close_file(fileop_ALPHA);
html_count++;
}
/*
* setup index char (for example, 'a' of '[a]').
* alpha is used for display.
* alpha_f is used for part of path.
*/
c = (unsigned char)*tag;
if (c > 127) {
int i2 = *(tag + 1) & 0xff;
/*
* for multi-byte(EUC) code.
*/
alpha[0] = *tag;
alpha[1] = *(tag + 1);
alpha[2] = '\0';
snprintf(alpha_f, sizeof(alpha_f), "%03d%03d", c, i2);
} else if (isalpha(c) || c == '_') {
alpha[0] = *tag;
alpha[1] = '\0';
/*
* for CD9660 or FAT file system
*/
if (islower(c)) {
alpha_f[0] = 'l';
alpha_f[1] = *tag;
alpha_f[2] = '\0';
} else {
alpha_f[0] = *tag;
alpha_f[1] = '\0';
}
} else {
alpha[0] = *tag;
alpha[1] = '\0';
snprintf(alpha_f, sizeof(alpha_f), "%03d", c);
}
snprintf(buf, sizeof(buf), "%s/defines/%s.%s", distpath, alpha_f, HTML);
fileop_ALPHA = open_output_file(buf, 0);
ALPHA = get_descripter(fileop_ALPHA);
snprintf(buf, sizeof(buf), "[%s]", alpha);
fputs_nl(gen_page_begin(buf, SUBDIR), ALPHA);
fputs_nl(body_begin, ALPHA);
fprintf(ALPHA, "%s[%s]%s\n", header_begin, alpha, header_end);
fputs(gen_href_begin_with_title(NULL, indexlink, normal_suffix, NULL, index_string), ALPHA);
if (Iflag)
fputs(gen_image(PARENT, back_icon, ".."), ALPHA);
else
fputs("[..]", ALPHA);
fputs_nl(gen_href_end(), ALPHA);
if (!no_order_list)
fputs_nl(list_begin, ALPHA);
else
fprintf(ALPHA, "%s%s\n", br, br);
STDOUT = ALPHA;
}
alpha_count++;
/*
* generating url for function definition.
*/
line = cache_get(GTAGS, tag);
strbuf_reset(url);
if (line == NULL)
die("internal error in makedefineindex().");
/*
* About the format of 'line', please see the head comment of cache.c.
*/
if (*line == ' ') {
const char *fid = line + 1;
const char *enumber = nextstring(fid);
snprintf(url_for_map, sizeof(url_for_map), "%s/%s.%s",
DEFS, fid, HTML);
if (dynamic) {
if (*action != '/' && aflag)
strbuf_puts(url, "../");
strbuf_puts(url, action);
strbuf_sprintf(url, "?pattern=%s%stype=definitions", tag, quote_amp);
} else {
if (aflag)
strbuf_puts(url, "../");
strbuf_sprintf(url, "%s/%s.%s", DEFS, fid, HTML);
}
snprintf(guide, sizeof(guide), "Multiple defined in %s places.", enumber);
} else {
const char *lno = line;
const char *fid = nextstring(line);
const char *path = gpath_fid2path(fid, NULL);
path += 2; /* remove './' */
snprintf(url_for_map, sizeof(url_for_map), "%s/%s.%s#L%s",
SRCS, fid, HTML, lno);
if (aflag)
strbuf_puts(url, "../");
strbuf_sprintf(url, "%s/%s.%s#L%s", SRCS, fid, HTML, lno);
snprintf(guide, sizeof(guide), "Defined at %s in %s.", lno, path);
}
if (!no_order_list)
fputs(item_begin, STDOUT);
fputs(gen_href_begin_with_title_target(NULL, strbuf_value(url), NULL, NULL, guide, target), STDOUT);
fputs(tag, STDOUT);
fputs(gen_href_end(), STDOUT);
if (!no_order_list)
fputs(item_end, STDOUT);
else
fputs(br, STDOUT);
fputc('\n', STDOUT);
if (map_file)
fprintf(MAP, "%s\t%s\n", tag, url_for_map);
}
if (pclose(TAGS) != 0)
die("terminated abnormally '%s' (errno = %d).", command, errno);
if (aflag && alpha[0]) {
char tmp[128];
const char *msg = (alpha_count == 1) ? "definition" : "definitions";
snprintf(tmp, sizeof(tmp), "%d %s", alpha_count, msg);
strbuf_puts(defines, gen_href_begin_with_title("defines", alpha_f, HTML, NULL, tmp));
strbuf_sprintf(defines, "[%s]", alpha);
strbuf_puts_nl(defines, gen_href_end());
if (!no_order_list)
fputs_nl(list_end, ALPHA);
else
fputs_nl(br, ALPHA);
fputs(gen_href_begin_with_title(NULL, indexlink, normal_suffix, NULL, index_string), ALPHA);
if (Iflag)
fputs(gen_image(PARENT, back_icon, ".."), ALPHA);
else
fputs("[..]", ALPHA);
fputs_nl(gen_href_end(), ALPHA);
fputs_nl(body_end, ALPHA);
fputs_nl(gen_page_end(), ALPHA);
close_file(fileop_ALPHA);
html_count++;
fputs(strbuf_value(defines), DEFINES);
}
if (!no_order_list && !aflag)
fputs_nl(list_end, DEFINES);
if (!aflag && !Fflag) {
fputs(gen_href_begin_with_title(NULL, "mains", normal_suffix, NULL, index_string), DEFINES);
if (Iflag)
fputs(gen_image(CURRENT, back_icon, ".."), DEFINES);
else
fputs("[..]", DEFINES);
fputs_nl(gen_href_end(), DEFINES);
}
fputs_nl(body_end, DEFINES);
fputs_nl(gen_page_end(), DEFINES);
close_file(fileop_DEFINES);
html_count++;
if (map_file)
close_file(fileop_MAP);
strbuf_close(sb);
strbuf_close(url);
return count;
}
/*----------------------------------------------------------------------*/
void
makeincludeindex(void)
{
FILE *PIPE;
STRBUF *input = strbuf_open(0);
char *ctags_x;
struct data *inc;
char *target = (Fflag) ? "mains" : "_top";
char command[MAXFILLEN];
/*
* Pick up include pattern.
*
* C: #include "xxx.h"
* PHP: include("xxx.inc.php");
*/
/*
* Unlike Perl regular expression, POSIX regular expression doesn't support C-style escape sequence.
* Therefore, we can not use "\\t" here.
*/
snprintf(command, sizeof(command), PQUOTE "%s -gnx --encode-path=\" \t\" \"^[ \t]*(#[ \t]*(import|include)|include[ \t]*\\()\"" PQUOTE, quote_shell(global_path));
if ((PIPE = popen(command, "r")) == NULL)
die("cannot execute '%s'.", command);
strbuf_reset(input);
while ((ctags_x = strbuf_fgets(input, PIPE, STRBUF_NOCRLF)) != NULL) {
SPLIT ptable;
char buf[MAXBUFLEN];
int is_php = 0;
const char *last, *lang, *suffix;
if (split(ctags_x, 4, &ptable) < 4) {
recover(&ptable);
die("too small number of parts in makefileindex().");
}
if ((suffix = locatestring(ptable.part[PART_PATH].start, ".", MATCH_LAST)) != NULL
&& (lang = decide_lang(suffix)) != NULL
&& strcmp(lang, "php") == 0)
is_php = 1;
last = extract_lastname(ptable.part[PART_LINE].start, is_php);
if (last == NULL || (inc = get_inc(last)) == NULL)
continue;
recover(&ptable);
/*
* s/^[^ \t]+/$last/;
*/
{
const char *p;
char *q = buf;
for (p = last; *p; p++)
*q++ = *p;
for (p = ctags_x; *p && *p != ' ' && *p != '\t'; p++)
;
for (; *p; p++)
*q++ = *p;
*q = '\0';
}
put_included(inc, buf);
}
if (pclose(PIPE) != 0)
die("terminated abnormally '%s' (errno = %d).", command, errno);
for (inc = first_inc(); inc; inc = next_inc()) {
const char *last = inc->name;
int no = inc->id;
FILEOP *fileop_INCLUDE;
FILE *INCLUDE;
if (inc->count > 1) {
char path[MAXPATHLEN];
snprintf(path, sizeof(path), "%s/%s/%d.%s", distpath, INCS, no, HTML);
fileop_INCLUDE = open_output_file(path, 0);
INCLUDE = get_descripter(fileop_INCLUDE);
fputs_nl(gen_page_begin(last, SUBDIR), INCLUDE);
fputs_nl(body_begin, INCLUDE);
fputs_nl(verbatim_begin, INCLUDE);
{
const char *filename = strbuf_value(inc->contents);
int count = inc->count;
for (; count; filename += strlen(filename) + 1, count--) {
fputs(gen_href_begin_with_title_target(upperdir(SRCS), path2fid(filename), HTML, NULL, NULL, target), INCLUDE);
fputs(removedotslash(filename), INCLUDE);
fputs_nl(gen_href_end(), INCLUDE);
}
}
fputs_nl(verbatim_end, INCLUDE);
fputs_nl(body_end, INCLUDE);
fputs_nl(gen_page_end(), INCLUDE);
close_file(fileop_INCLUDE);
html_count++;
/*
* inc->contents == NULL means that information already
* written to file.
*/
strbuf_close(inc->contents);
inc->contents = NULL;
}
if (!inc->ref_count)
continue;
if (inc->ref_count == 1) {
SPLIT ptable;
char buf[1024];
if (split(strbuf_value(inc->ref_contents), 4, &ptable) < 4) {
recover(&ptable);
die("too small number of parts in makefileindex().");
}
snprintf(buf, sizeof(buf), "%s %s", ptable.part[PART_LNO].start, decode_path(ptable.part[PART_PATH].start));
recover(&ptable);
strbuf_reset(inc->ref_contents);
strbuf_puts(inc->ref_contents, buf);
} else {
char path[MAXPATHLEN];
snprintf(path, sizeof(path), "%s/%s/%d.%s", distpath, INCREFS, no, HTML);
fileop_INCLUDE = open_output_file(path, 0);
INCLUDE = get_descripter(fileop_INCLUDE);
fputs_nl(gen_page_begin(last, SUBDIR), INCLUDE);
fputs_nl(body_begin, INCLUDE);
fputs_nl(gen_list_begin(), INCLUDE);
{
const char *line = strbuf_value(inc->ref_contents);
int count = inc->ref_count;
for (; count; line += strlen(line) + 1, count--)
fputs_nl(gen_list_body(upperdir(SRCS), line, NULL), INCLUDE);
}
fputs_nl(gen_list_end(), INCLUDE);
fputs_nl(body_end, INCLUDE);
fputs_nl(gen_page_end(), INCLUDE);
close_file(fileop_INCLUDE);
html_count++;
/*
* inc->ref_contents == NULL means that information already
* written to file.
*/
strbuf_close(inc->ref_contents);
inc->ref_contents = NULL;
}
}
strbuf_close(input);
}
/*
* Make duplicate object index.
*
* If referred tag is only one, direct link which points the tag is generated.
* Else if two or more tag exists, indirect link which points the tag list
* is generated.
*/
int
makedupindex(void)
{
STRBUF *sb = strbuf_open(0);
STRBUF *tmp = strbuf_open(0);
STRBUF *command = strbuf_open(0);
int definition_count = 0;
char srcdir[MAXPATHLEN];
int db;
FILEOP *fileop = NULL;
FILE *op = NULL;
FILE *ip = NULL;
snprintf(srcdir, sizeof(srcdir), "../%s", SRCS);
for (db = GTAGS; db < GTAGLIM; db++) {
const char *kind = kinds[db];
const char *option = options[db];
int writing = 0;
int count = 0;
int entry_count = 0;
const char *ctags_xid, *ctags_x;
char tag[IDENTLEN], prev[IDENTLEN], first_line[MAXBUFLEN];
if (gtags_exist[db] == 0)
continue;
prev[0] = 0;
first_line[0] = 0;
/*
* construct command line.
*/
strbuf_reset(command);
strbuf_sprintf(command, "%s -x%s --result=ctags-xid --encode-path=\" \t\" --nofilter=path", quote_shell(global_path), option);
/*
* Optimization when the --dynamic option is specified.
*/
if (dynamic) {
strbuf_puts(command, " --nosource");
if (db != GSYMS)
strbuf_puts(command, " --nofilter=sort");
}
strbuf_puts(command, " \".*\"");
if ((ip = popen(strbuf_value(command), "r")) == NULL)
die("cannot execute command '%s'.", strbuf_value(command));
while ((ctags_xid = strbuf_fgets(sb, ip, STRBUF_NOCRLF)) != NULL) {
char fid[MAXFIDLEN];
ctags_x = parse_xid(ctags_xid, fid, NULL);
/* tag name */
(void)strcpy_withterm(tag, ctags_x, sizeof(tag), ' ');
if (strcmp(prev, tag)) {
count++;
if (vflag)
fprintf(stderr, " [%d] adding %s %s\n", count, kind, tag);
if (writing) {
if (!dynamic) {
fputs_nl(gen_list_end(), op);
fputs_nl(body_end, op);
fputs_nl(gen_page_end(), op);
close_file(fileop);
html_count++;
}
writing = 0;
/*
* cache record: " <fid>\0<entry number>\0"
*/
strbuf_reset(tmp);
strbuf_putc(tmp, ' ');
strbuf_putn(tmp, count - 1);
strbuf_putc(tmp, '\0');
strbuf_putn(tmp, entry_count);
cache_put(db, prev, strbuf_value(tmp), strbuf_getlen(tmp) + 1);
}
/* single entry */
if (first_line[0]) {
char fid[MAXFIDLEN];
const char *ctags_x = parse_xid(first_line, fid, NULL);
const char *lno = nextelement(ctags_x);
strbuf_reset(tmp);
strbuf_puts_withterm(tmp, lno, ' ');
strbuf_putc(tmp, '\0');
strbuf_puts(tmp, fid);
cache_put(db, prev, strbuf_value(tmp), strbuf_getlen(tmp) + 1);
}
/*
* Chop the tail of the line. It is not important.
* strlimcpy(first_line, ctags_x, sizeof(first_line));
*/
strncpy(first_line, ctags_xid, sizeof(first_line));
first_line[sizeof(first_line) - 1] = '\0';
strlimcpy(prev, tag, sizeof(prev));
entry_count = 0;
} else {
/* duplicate entry */
if (first_line[0]) {
char fid[MAXFIDLEN];
const char *ctags_x = parse_xid(first_line, fid, NULL);
if (!dynamic) {
char path[MAXPATHLEN];
snprintf(path, sizeof(path), "%s/%s/%d.%s", distpath, dirs[db], count, HTML);
fileop = open_output_file(path, cflag);
op = get_descripter(fileop);
fputs_nl(gen_page_begin(tag, SUBDIR), op);
fputs_nl(body_begin, op);
fputs_nl(gen_list_begin(), op);
fputs_nl(gen_list_body(srcdir, ctags_x, fid), op);
}
writing = 1;
entry_count++;
first_line[0] = 0;
}
if (!dynamic) {
fputs_nl(gen_list_body(srcdir, ctags_x, fid), op);
}
entry_count++;
}
}
if (db == GTAGS)
definition_count = count;
if (pclose(ip) != 0)
die("'%s' failed.", strbuf_value(command));
if (writing) {
if (!dynamic) {
fputs_nl(gen_list_end(), op);
fputs_nl(body_end, op);
fputs_nl(gen_page_end(), op);
close_file(fileop);
html_count++;
}
/*
* cache record: " <fid>\0<entry number>\0"
*/
strbuf_reset(tmp);
strbuf_putc(tmp, ' ');
strbuf_putn(tmp, count);
strbuf_putc(tmp, '\0');
strbuf_putn(tmp, entry_count);
cache_put(db, prev, strbuf_value(tmp), strbuf_getlen(tmp) + 1);
}
if (first_line[0]) {
char fid[MAXFIDLEN];
const char *ctags_x = parse_xid(first_line, fid, NULL);
const char *lno = nextelement(ctags_x);
strbuf_reset(tmp);
strbuf_puts_withterm(tmp, lno, ' ');
strbuf_putc(tmp, '\0');
strbuf_puts(tmp, fid);
cache_put(db, prev, strbuf_value(tmp), strbuf_getlen(tmp) + 1);
}
}
strbuf_close(sb);
strbuf_close(tmp);
strbuf_close(command);
return definition_count;
}
static int
print_directory(int level, char *basedir)
{
const char *path;
FILEOP *fileop = NULL;
FILE *op = NULL;
int flist_items = 0;
int count = 0;
if (level > 0) {
char name[MAXPATHLEN];
snprintf(name, sizeof(name), "%s/files/%s.%s", distpath, path2fid(basedir), HTML);
fileop = open_output_file(name, 0);
op = get_descripter(fileop);
print_directory_header(op, level, basedir);
if (tree_view) {
char *target = (Fflag) ? "mains" : "_top";
strbuf_puts(files, dir_begin);
strbuf_puts(files, gen_href_begin_with_title_target("files", path2fid(basedir), HTML, NULL, NULL, target));
strbuf_puts(files, full_path ? removedotslash(basedir) : lastpart(basedir));
strbuf_puts(files, gen_href_end());
strbuf_puts_nl(files, dir_title_end);
strbuf_puts_nl(files, "<ul>");
}
}
while ((path = getpath()) != NULL) {
const char *p, *local = localpath(path, basedir);
/*
* Path is outside of basedir.
*/
if (local == NULL) {
ungetpath(); /* read again by upper level print_directory(). */
break;
}
/*
* Path is inside of basedir.
*/
else {
char *slash = strchr(local, '/');
if (table_flist && flist_items++ % flist_fields == 0)
PUT(fline_begin);
/*
* Print directory.
*/
if (slash) {
int baselen = strlen(basedir);
char *q, *last = basedir + baselen;
int subcount;
if (baselen + 1 + (slash - local) > MAXPATHLEN) {
fprintf(stderr, "Too long path name.\n");
exit(1);
}
/*
* Append new directory to the basedir.
*/
p = local;
q = last;
*q++ = '/';
while (p < slash)
*q++ = *p++;
*q = '\0';
/*
* print tree for this directory.
*/
ungetpath(); /* read again by lower level print_directory(). */
subcount = print_directory(level + 1, basedir);
PUT(print_directory_name(level, basedir, subcount));
count += subcount;
/*
* Shrink the basedir.
*/
*last = '\0';
}
/*
* Print file.
*/
else {
const char *file_name = print_file_name(level, path);
if (tree_view) {
int size = filesize(path);
char *target = (Fflag) ? "mains" : "_top";
char tips[80];
if (size > 1)
snprintf(tips, sizeof(tips), "%s bytes", insert_comma(size));
else
snprintf(tips, sizeof(tips), "%s byte", insert_comma(size));
strbuf_sprintf(files, "%s%s%s%s%s\n",
file_begin,
gen_href_begin_with_title_target(SRCS, path2fid(path), HTML, NULL, tips, target),
full_path ? removedotslash(path) : lastpart(path),
gen_href_end(),
file_end);
}
PUT(file_name);
if (filemap_file)
fprintf(FILEMAP, "%s\t%s/%s.%s\n", removedotslash(path), SRCS, path2fid(path), HTML);
count++;
}
if (table_flist && flist_items % flist_fields == 0)
PUT(fline_end);
}
}
if (flist_items % flist_fields != 0)
PUT(fline_end);
if (level > 0) {
print_directory_footer(op, level, basedir);
close_file(fileop);
if (tree_view) {
strbuf_puts_nl(files, "</ul>");
strbuf_puts_nl(files, dir_end);
}
}
html_count++;
return count;
}
