/*---------------------------------------------------------------------------*/
void
cc26xx_uart_set_input(int (*input)(unsigned char c))
{
input_handler = input;
/* Return early if disabled by user conf or if ports are misconfigured */
if(usable() == false) {
return;
}
if(input == NULL) {
/* Let the SERIAL PD power down */
uart_module.domain_lock = LPM_DOMAIN_NONE;
/* Disable module clocks under sleep and deep sleep */
ti_lib_prcm_peripheral_sleep_disable(PRCM_PERIPH_UART0);
ti_lib_prcm_peripheral_deep_sleep_disable(PRCM_PERIPH_UART0);
} else {
/* Request the SERIAL PD to stay on during deep sleep */
uart_module.domain_lock = LPM_DOMAIN_SERIAL;
/* Enable module clocks under sleep and deep sleep */
ti_lib_prcm_peripheral_sleep_enable(PRCM_PERIPH_UART0);
ti_lib_prcm_peripheral_deep_sleep_enable(PRCM_PERIPH_UART0);
}
ti_lib_prcm_load_set();
while(!ti_lib_prcm_load_get());
enable();
return;
}
/* UNIX version */
void
show_page_by_url(const char *browser, const char *url)
{
char com[1024];
/*
* Browsers which have openURL() command.
*/
if (locatestring(browser, "mozilla", MATCH_AT_LAST) ||
locatestring(browser, "netscape", MATCH_AT_LAST) ||
locatestring(browser, "netscape-remote", MATCH_AT_LAST))
{
char *path;
if (!(path = usable(browser)))
die("%s not found in your path.", browser);
snprintf(com, sizeof(com), "%s -remote \"openURL(%s)\"", path, url);
}
/*
* Generic browser.
*/
else {
snprintf(com, sizeof(com), "%s \"%s\"", browser, url);
}
system(com);
}
/*---------------------------------------------------------------------------*/
void
cc26xx_uart_init()
{
bool interrupts_disabled;
/* Return early if disabled by user conf or if ports are misconfigured */
if(usable() == false) {
return;
}
/* Disable Interrupts */
interrupts_disabled = ti_lib_int_master_disable();
/* Register ourselves with the LPM module */
lpm_register_module(&uart_module);
/* Only TX and EN to start with. RX will be enabled only if needed */
input_handler = NULL;
/*
* init() won't actually fire up the UART. We turn it on only when (and if)
* it gets requested, either to enable input or to send out a character
*
* Thus, we simply re-enable processor interrupts here
*/
if(!interrupts_disabled) {
ti_lib_int_master_enable();
}
}
/*
* Get global(1)'s path.
*/
static void
get_global_path(void)
{
const char *p;
if (!(p = usable("global")))
die("global command required but not found.");
strlimcpy(global_path, p, sizeof(global_path));
}
void ScFace::unload() const
{
if (m_m->status >= ScFace::LOADED && usable()) {
m_m->unload();
}
// clear caches
m_m->m_glyphWidth.clear();
m_m->m_glyphOutline.clear();
//m->m_cMap.clear();
m_m->status = ScFace::UNKNOWN;
}
/* DJGPP version */
void
show_page_by_url(const char *browser, const char *url)
{
char com[MAXFILLEN+1];
char *path;
/*
* assume a Windows browser if it's not on the path.
*/
if (!(path = usable(browser))) {
/*
* START is an internal command in XP, external in 9X.
*/
if (!(path = usable("start")))
path = "cmd /c start";
snprintf(com, sizeof(com), "%s %s \"%s\"", path, browser, url);
} else {
snprintf(com, sizeof(com), "%s \"%s\"", path, url);
}
system(com);
}
/**
* basic check.
*/
static void
basic_check(void)
{
const char *p;
/*
* COMMAND EXISTENCE CHECK
*/
if (!(p = usable("gtags")))
die("gtags command required but not found.");
strlimcpy(gtags_path, p, sizeof(gtags_path));
if (!(p = usable("global")))
die("global command required but not found.");
strlimcpy(global_path, p, sizeof(global_path));
/*
* Temporary directory.
*/
if ((p = getenv("TMPDIR")) == NULL)
p = getenv("TMP");
if (p != NULL && test("d", p))
tmpdir = p;
}
/*---------------------------------------------------------------------------*/
void
cc26xx_uart_write_byte(uint8_t c)
{
/* Return early if disabled by user conf or if ports are misconfigured */
if(usable() == false) {
return;
}
if(accessible() == false) {
enable();
}
ti_lib_uart_char_put(UART0_BASE, c);
}
/*---------------------------------------------------------------------------*/
uint8_t
cc26xx_uart_busy(void)
{
/* Return early if disabled by user conf or if ports are misconfigured */
if(usable() == false) {
return UART_IDLE;
}
/* If the UART is not accessible, it is not busy */
if(accessible() == false) {
return UART_IDLE;
}
return ti_lib_uart_busy(UART0_BASE);
}
/**
* completion_idutils: print completion list of specified @a prefix
*
* @param[in] dbpath dbpath directory
* @param[in] root root directory
* @param[in] prefix prefix of primary key
*/
void
completion_idutils(const char *dbpath, const char *root, const char *prefix)
{
FILE *ip;
STRBUF *sb = strbuf_open(0);
const char *lid = usable("lid");
char *line, *p;
if (prefix && *prefix == 0) /* In the case global -c '' */
prefix = NULL;
/*
* make lid command line.
* Invoke lid with the --result=grep option to generate grep format.
*/
if (!lid)
die("lid(idutils) not found.");
strbuf_puts(sb, lid);
strbuf_sprintf(sb, " --file=%s/ID", quote_shell(dbpath));
strbuf_puts(sb, " --key=token");
if (iflag)
strbuf_puts(sb, " --ignore-case");
if (prefix) {
strbuf_putc(sb, ' ');
strbuf_putc(sb, '"');
strbuf_putc(sb, '^');
strbuf_puts(sb, prefix);
strbuf_putc(sb, '"');
}
if (debug)
fprintf(stderr, "completion_idutils: %s\n", strbuf_value(sb));
if (chdir(root) < 0)
die("cannot move to '%s' directory.", root);
if (!(ip = popen(strbuf_value(sb), "r")))
die("cannot execute '%s'.", strbuf_value(sb));
while ((line = strbuf_fgets(sb, ip, STRBUF_NOCRLF)) != NULL) {
for (p = line; *p && *p != ' '; p++)
;
if (*p == '\0') {
warning("Invalid line: %s", line);
continue;
}
*p = '\0';
puts(line);
}
if (pclose(ip) != 0)
die("terminated abnormally (errno = %d).", errno);
strbuf_close(sb);
}
STATIC void node_compact(Node_s *node)
{
u8 b[BLOCK_SIZE];
Node_s *h = (Node_s *)b;
int i;
if (usable(node) == node->free) {
return;
}
zero(b);
init_node(h, node->blknum);
for (i = 0; i < node->numrecs; i++) {
rec_copy(h, i, node, i);
}
memmove(node, h, BLOCK_SIZE);
}
bool ScFace::canRender(QChar ch) const
{
if (!usable())
return false;
else {
gid_type gl = char2CMap(ch); // calls load()
if (gl >= CONTROL_GLYPHS) // those are always empty
return true;
else if (gl != 0) {
m_m->loadGlyph(gl);
return ! m_m->m_glyphOutline[gl].broken;
}
else {
return false;
}
}
}
int
main(int argc, char **argv)
{
const char *av = NULL;
int db;
int optchar;
int option_index = 0;
while ((optchar = getopt_long(argc, argv, "ace:ifgGIlL:noOpPqrstTuvVx", long_options, &option_index)) != EOF) {
switch (optchar) {
case 0:
break;
case 'a':
aflag++;
break;
case 'c':
cflag++;
setcom(optchar);
break;
case 'e':
av = optarg;
break;
case 'f':
fflag++;
xflag++;
setcom(optchar);
break;
case 'g':
gflag++;
setcom(optchar);
break;
case 'G':
Gflag++;
break;
case 'i':
iflag++;
break;
case 'I':
Iflag++;
setcom(optchar);
break;
case 'l':
lflag++;
break;
case 'L':
file_list = optarg;
break;
case 'n':
nflag++;
if (optarg) {
if (!strcmp(optarg, "sort"))
nofilter |= SORT_FILTER;
else if (!strcmp(optarg, "path"))
nofilter |= PATH_FILTER;
} else {
nofilter = BOTH_FILTER;
}
break;
case 'o':
oflag++;
break;
case 'O':
Oflag++;
break;
case 'p':
pflag++;
setcom(optchar);
break;
case 'P':
Pflag++;
setcom(optchar);
break;
case 'q':
qflag++;
setquiet();
break;
case 'r':
rflag++;
break;
case 's':
sflag++;
break;
case 't':
tflag++;
break;
case 'T':
Tflag++;
break;
case 'u':
uflag++;
setcom(optchar);
break;
case 'v':
vflag++;
break;
case 'V':
Vflag++;
break;
case 'x':
xflag++;
break;
case ENCODE_PATH:
if (strlen(optarg) > 255)
die("too many encode chars.");
if (strchr(optarg, '/') || strchr(optarg, '.'))
die("cannot encode '/' and '.' in the path.");
set_encode_chars((unsigned char *)optarg);
break;
case FROM_HERE:
{
char *p = optarg;
const char *usage = "usage: global --from-here=lineno:path.";
context_lineno = p;
while (*p && isdigit(*p))
p++;
if (*p != ':')
die_with_code(2, usage);
*p++ = '\0';
if (!*p)
die_with_code(2, usage);
context_file = p;
}
break;
case RESULT:
if (!strcmp(optarg, "ctags-x"))
format = FORMAT_CTAGS_X;
else if (!strcmp(optarg, "ctags-xid"))
format = FORMAT_CTAGS_XID;
else if (!strcmp(optarg, "ctags"))
format = FORMAT_CTAGS;
else if (!strcmp(optarg, "path"))
format = FORMAT_PATH;
else if (!strcmp(optarg, "grep"))
format = FORMAT_GREP;
else if (!strcmp(optarg, "cscope"))
format = FORMAT_CSCOPE;
else
die_with_code(2, "unknown format type for the --result option.");
break;
default:
usage();
break;
}
}
if (qflag)
vflag = 0;
if (show_help)
help();
argc -= optind;
argv += optind;
/*
* At first, we pickup pattern from -e option. If it is not found
* then use argument which is not option.
*/
if (!av) {
av = *argv;
/*
* global -g pattern [files ...]
* av argv
*/
if (gflag && av)
argv++;
}
if (show_version)
version(av, vflag);
/*
* only -c, -u, -P and -p allows no argument.
*/
if (!av) {
switch (command) {
case 'c':
case 'u':
case 'p':
case 'P':
break;
case 'f':
if (file_list)
break;
default:
usage();
break;
}
}
/*
* -u and -p cannot have any arguments.
*/
if (av) {
switch (command) {
case 'u':
case 'p':
usage();
default:
break;
}
}
if (tflag)
xflag = 0;
if (nflag > 1)
nosource = 1; /* to keep compatibility */
if (print0)
set_print0();
/*
* remove leading blanks.
*/
if (!Iflag && !gflag && av)
for (; *av == ' ' || *av == '\t'; av++)
;
if (cflag && av && isregex(av))
die_with_code(2, "only name char is allowed with -c option.");
/*
* get path of following directories.
* o current directory
* o root of source tree
* o dbpath directory
*
* if GTAGS not found, getdbpath doesn't return.
*/
getdbpath(cwd, root, dbpath, (pflag && vflag));
/*
* print dbpath or rootdir.
*/
if (pflag) {
fprintf(stdout, "%s\n", (rflag) ? root : dbpath);
exit(0);
}
/*
* incremental update of tag files.
*/
if (uflag) {
STRBUF *sb = strbuf_open(0);
char *gtags = usable("gtags");
if (!gtags)
die("gtags command not found.");
if (chdir(root) < 0)
die("cannot change directory to '%s'.", root);
strbuf_puts(sb, gtags);
strbuf_puts(sb, " -i");
if (vflag)
strbuf_putc(sb, 'v');
strbuf_putc(sb, ' ');
strbuf_puts(sb, dbpath);
if (system(strbuf_value(sb)))
exit(1);
strbuf_close(sb);
exit(0);
}
/*
* complete function name
*/
if (cflag) {
if (Iflag)
completion_idutils(dbpath, root, av);
else
completion(dbpath, root, av);
exit(0);
}
/*
* make local prefix.
* local prefix must starts with './' and ends with '/'.
*/
if (lflag) {
STRBUF *sb = strbuf_open(0);
strbuf_putc(sb, '.');
if (strcmp(root, cwd) != 0) {
char *p = cwd + strlen(root);
if (*p != '/')
strbuf_putc(sb, '/');
strbuf_puts(sb, p);
}
strbuf_putc(sb, '/');
localprefix = check_strdup(strbuf_value(sb));
strbuf_close(sb);
#ifdef DEBUG
fprintf(stderr, "root=%s\n", root);
fprintf(stderr, "cwd=%s\n", cwd);
fprintf(stderr, "localprefix=%s\n", localprefix);
#endif
}
/*
* decide tag type.
*/
if (context_file) {
if (isregex(av))
die_with_code(2, "regular expression is not allowed with the --from-here option.");
db = decide_tag_by_context(av, context_file, atoi(context_lineno));
} else {
if (rflag && sflag)
db = GRTAGS + GSYMS;
else
db = (rflag) ? GRTAGS : ((sflag) ? GSYMS : GTAGS);
}
/*
* decide format.
* The --result option is given to priority more than the -t and -x option.
*/
if (format == 0) {
if (tflag) { /* ctags format */
format = FORMAT_CTAGS;
} else if (xflag) { /* print details */
format = FORMAT_CTAGS_X;
} else { /* print just a file name */
format = FORMAT_PATH;
}
}
/*
* decide path conversion type.
*/
if (nofilter & PATH_FILTER)
type = PATH_THROUGH;
else if (aflag)
type = PATH_ABSOLUTE;
else
type = PATH_RELATIVE;
/*
* exec lid(idutils).
*/
if (Iflag) {
chdir(root);
idutils(av, dbpath);
}
/*
* search pattern (regular expression).
*/
else if (gflag) {
chdir(root);
grep(av, argv, dbpath);
}
/*
* locate paths including the pattern.
*/
else if (Pflag) {
chdir(root);
pathlist(av, dbpath);
}
/*
* parse source files.
*/
else if (fflag) {
chdir(root);
parsefile(argv, cwd, root, dbpath, db);
}
/*
* tag search.
*/
else {
tagsearch(av, cwd, root, dbpath, db);
}
return 0;
}
int
main(int argc, char **argv)
{
const char *av = NULL;
int func_total, file_total;
char arg_dbpath[MAXPATHLEN];
const char *index = NULL;
int optchar;
int option_index = 0;
STATISTICS_TIME *tim;
arg_dbpath[0] = 0;
basic_check();
/*
* Setup GTAGSCONF and GTAGSLABEL environment variable
* according to the --gtagsconf and --gtagslabel option.
*/
preparse_options(argc, argv);
/*
* Load configuration values.
*/
if (!vgetcwd(cwdpath, sizeof(cwdpath)))
die("cannot get current directory.");
openconf(cwdpath);
configuration();
/*
* setup_langmap() is needed to use decide_lang().
*/
setup_langmap(langmap);
save_environment(argc, argv);
/*
* insert htags_options at the head of argv.
*/
setenv_from_config();
{
char *env = getenv("HTAGS_OPTIONS");
if (env && *env)
argv = prepend_options(&argc, argv, env);
}
while ((optchar = getopt_long(argc, argv, "acd:DfFghIm:nNoqst:Tvwx", long_options, &option_index)) != EOF) {
switch (optchar) {
case 0:
/* already flags set */
break;
case OPT_AUTO_COMPLETION:
auto_completion = 1;
if (optarg) {
if (atoi(optarg) > 0)
auto_completion_limit = optarg;
else
die("The option value of --auto-completion must be numeric.");
}
break;
case OPT_CFLOW:
call_file = optarg;
break;
case OPT_CALL_TREE:
call_file = optarg;
break;
case OPT_CALLEE_TREE:
callee_file = optarg;
break;
case OPT_CVSWEB:
cvsweb_url = optarg;
break;
case OPT_CVSWEB_CVSROOT:
cvsweb_cvsroot = optarg;
break;
case OPT_GTAGSCONF:
case OPT_GTAGSLABEL:
/* These options are already parsed in preparse_options() */
break;
case OPT_INSERT_FOOTER:
insert_footer = optarg;
break;
case OPT_INSERT_HEADER:
insert_header = optarg;
break;
case OPT_HTML_HEADER:
{
STATIC_STRBUF(sb);
if (!test("r", optarg))
die("file '%s' not found.", optarg);
strbuf_clear(sb);
loadfile(optarg, sb);
html_header = strbuf_value(sb);
}
break;
case OPT_ITEM_ORDER:
item_order = optarg;
break;
case OPT_TABS:
if (atoi(optarg) > 0)
tabs = atoi(optarg);
else
die("--tabs option requires numeric value.");
break;
case OPT_NCOL:
if (atoi(optarg) > 0)
ncol = atoi(optarg);
else
die("--ncol option requires numeric value.");
break;
case OPT_TREE_VIEW:
tree_view = 1;
if (optarg)
tree_view_type = optarg;
break;
case 'a':
aflag++;
break;
case 'd':
strlimcpy(arg_dbpath, optarg, sizeof(arg_dbpath));
break;
case 'D':
dynamic = 1;
break;
case 'f':
fflag++;
break;
case 'F':
Fflag++;
break;
case 'g':
gflag++;
break;
case 'h':
definition_header = AFTER_HEADER;
if (optarg) {
if (!strcmp(optarg, "before"))
definition_header = BEFORE_HEADER;
else if (!strcmp(optarg, "right"))
definition_header = RIGHT_HEADER;
else if (!strcmp(optarg, "after"))
definition_header = AFTER_HEADER;
else
die("The option value of --func-header must be one of 'before', 'right' and 'after'.");
}
break;
case 'I':
Iflag++;
break;
case 'm':
main_func = optarg;
break;
case 'n':
nflag++;
if (optarg) {
if (atoi(optarg) > 0)
ncol = atoi(optarg);
else
die("The option value of --line-number must be numeric.");
}
break;
case 'o':
other_files = 1;
break;
case 's':
symbol = 1;
break;
case 'T':
table_flist = 1;
if (optarg) {
if (atoi(optarg) > 0)
flist_fields = atoi(optarg);
else
die("The option value of the --table-flist must be numeric.");
}
break;
case 't':
title = optarg;
break;
case 'q':
qflag++;
setquiet();
break;
case 'v':
vflag++;
setverbose();
break;
case 'w':
wflag++;
break;
default:
usage();
break;
}
}
/*
* Leaving everything to htags.
* Htags selects popular options for you.
*/
if (suggest2)
suggest = 1;
if (suggest) {
int gtags_not_found = 0;
char dbpath[MAXPATHLEN];
aflag = Iflag = nflag = vflag = 1;
setverbose();
definition_header = AFTER_HEADER;
other_files = symbol = show_position = table_flist = fixed_guide = 1;
if (arg_dbpath[0]) {
if (!test("f", makepath(arg_dbpath, dbname(GTAGS), NULL)))
gtags_not_found = 1;
} else if (gtagsexist(".", dbpath, sizeof(dbpath), 0) == 0) {
gtags_not_found = 1;
}
if (gtags_not_found)
gflag = 1;
}
if (suggest2) {
Fflag = 1; /* uses frame */
fflag = dynamic = 1; /* needs a HTTP server */
auto_completion = tree_view = 1; /* needs javascript */
}
if (call_file && !test("fr", call_file))
die("cflow file not found. '%s'", call_file);
if (callee_file && !test("fr", callee_file))
die("cflow file not found. '%s'", callee_file);
if (insert_header && !test("fr", insert_header))
die("page header file '%s' not found.", insert_header);
if (insert_footer && !test("fr", insert_footer))
die("page footer file '%s' not found.", insert_footer);
if (!fflag)
auto_completion = 0;
argc -= optind;
argv += optind;
if (!av)
av = (argc > 0) ? *argv : NULL;
if (debug)
setdebug();
settabs(tabs); /* setup tab skip */
if (qflag) {
setquiet();
vflag = 0;
}
if (show_version)
version(av, vflag);
if (show_help)
help();
/*
* Invokes gtags beforehand.
*/
if (gflag) {
STRBUF *sb = strbuf_open(0);
strbuf_puts(sb, gtags_path);
if (vflag)
strbuf_puts(sb, " -v");
if (wflag)
strbuf_puts(sb, " -w");
if (suggest2 && enable_idutils && usable("mkid"))
strbuf_puts(sb, " -I");
if (arg_dbpath[0]) {
strbuf_putc(sb, ' ');
strbuf_puts(sb, arg_dbpath);
}
if (system(strbuf_value(sb)))
die("cannot execute gtags(1) command.");
strbuf_close(sb);
}
/*
* get dbpath.
*/
if (arg_dbpath[0]) {
strlimcpy(dbpath, arg_dbpath, sizeof(dbpath));
} else {
int status = setupdbpath(0);
if (status < 0)
die_with_code(-status, "%s", gtags_dbpath_error);
strlimcpy(dbpath, get_dbpath(), sizeof(dbpath));
}
if (!title) {
char *p = strrchr(cwdpath, sep);
title = p ? p + 1 : cwdpath;
}
if (cvsweb_url && test("d", "CVS"))
use_cvs_module = 1;
/*
* decide directory in which we make hypertext.
*/
if (av) {
char realpath[MAXPATHLEN];
if (!test("dw", av))
die("'%s' is not writable directory.", av);
if (chdir(av) < 0)
die("directory '%s' not found.", av);
if (!vgetcwd(realpath, sizeof(realpath)))
die("cannot get current directory");
if (chdir(cwdpath) < 0)
die("cannot return to original directory.");
snprintf(distpath, sizeof(distpath), "%s/HTML", realpath);
} else {
snprintf(distpath, sizeof(distpath), "%s/HTML", cwdpath);
}
/*
* Existence check of tag files.
*/
{
int i;
const char *path;
GTOP *gtop;
for (i = GPATH; i < GTAGLIM; i++) {
path = makepath(dbpath, dbname(i), NULL);
gtags_exist[i] = test("fr", path);
}
/*
* Real GRTAGS includes virtual GSYMS.
*/
gtags_exist[GSYMS] = symbol ? 1 : 0;
if (!gtags_exist[GPATH] || !gtags_exist[GTAGS] || !gtags_exist[GRTAGS])
die("GPATH, GTAGS and/or GRTAGS not found. Please reexecute htags with the -g option.");
/*
* version check.
* Do nothing, but the version of tag file will be checked.
*/
gtop = gtags_open(dbpath, cwdpath, GTAGS, GTAGS_READ, 0);
gtags_close(gtop);
/*
* Check whether GRTAGS is empty.
*/
gtop = gtags_open(dbpath, cwdpath, GRTAGS, GTAGS_READ, 0);
if (gtags_first(gtop, NULL, 0) == NULL)
grtags_is_empty = 1;
gtags_close(gtop);
}
/*
* make dbpath absolute.
*/
{
char buf[MAXPATHLEN];
if (realpath(dbpath, buf) == NULL)
die("cannot get realpath of dbpath.");
strlimcpy(dbpath, buf, sizeof(dbpath));
}
/*
* The older version (4.8.7 or former) of GPATH doesn't have files
* other than source file. The oflag requires new version of GPATH.
*/
if (other_files) {
GFIND *gp = gfind_open(dbpath, NULL, 0, 0);
if (gp->version < 2)
die("GPATH is old format. Please remake it by invoking gtags(1).");
gfind_close(gp);
}
/*
* for global(1) and gtags(1).
*/
set_env("GTAGSROOT", cwdpath);
set_env("GTAGSDBPATH", dbpath);
set_env("GTAGSLIBPATH", "");
/*------------------------------------------------------------------
* MAKE FILES
*------------------------------------------------------------------
* HTML/cgi-bin/global.cgi ... CGI program (1)
* HTML/cgi-bin/ghtml.cgi ... unzip script (1)
* HTML/.htaccess ... skeleton of .htaccess (1)
* HTML/help.html ... help file (2)
* HTML/R/ ... references (3)
* HTML/D/ ... definitions (3)
* HTML/search.html ... search index (4)
* HTML/defines.html ... definitions index (5)
* HTML/defines/ ... definitions index (5)
* HTML/files/ ... file index (6)
* HTML/index.html ... index file (7)
* HTML/mains.html ... main index (8)
* HTML/null.html ... main null html (8)
* HTML/S/ ... source files (9)
* HTML/I/ ... include file index (9)
* HTML/rebuild.sh ... rebuild script (10)
* HTML/style.css ... style sheet (11)
*------------------------------------------------------------------
*/
/* for clean up */
signal_setup();
sethandler(clean);
HTML = normal_suffix;
message("[%s] Htags started", now());
init_statistics();
/*
* (#) check if GTAGS, GRTAGS is the latest.
*/
if (get_dbpath())
message(" Using %s/GTAGS.", get_dbpath());
if (grtags_is_empty)
message(" GRTAGS is empty.");
if (gpath_open(dbpath, 0) < 0)
die("GPATH not found.");
if (!w32) {
/* UNDER CONSTRUCTION */
}
if (auto_completion || tree_view) {
STATIC_STRBUF(sb);
strbuf_clear(sb);
strbuf_puts_nl(sb, "<script type='text/javascript' src='js/jquery.js'></script>");
if (auto_completion)
loadfile(makepath(datadir, "gtags/jscode_suggest", NULL), sb);
if (tree_view)
loadfile(makepath(datadir, "gtags/jscode_treeview", NULL), sb);
jscode = strbuf_value(sb);
}
/*
* (0) make directories
*/
message("[%s] (0) making directories ...", now());
if (!test("d", distpath))
if (mkdir(distpath, 0777) < 0)
die("cannot make directory '%s'.", distpath);
make_directory_in_distpath("files");
make_directory_in_distpath("defines");
make_directory_in_distpath(SRCS);
make_directory_in_distpath(INCS);
make_directory_in_distpath(INCREFS);
if (!dynamic) {
make_directory_in_distpath(DEFS);
make_directory_in_distpath(REFS);
if (symbol)
make_directory_in_distpath(SYMS);
}
if (fflag || dynamic)
make_directory_in_distpath("cgi-bin");
if (Iflag)
make_directory_in_distpath("icons");
if (auto_completion || tree_view)
make_directory_in_distpath("js");
/*
* (1) make CGI program
*/
if (fflag || dynamic) {
char cgidir[MAXPATHLEN];
snprintf(cgidir, sizeof(cgidir), "%s/cgi-bin", distpath);
message("[%s] (1) making CGI program ...", now());
if (fflag || dynamic)
makeprogram(cgidir, "global.cgi", 0755);
if (auto_completion)
makeprogram(cgidir, "completion.cgi", 0755);
makehtaccess(cgidir, ".htaccess", 0644);
} else {
message("[%s] (1) making CGI program ...(skipped)", now());
}
if (av) {
const char *path = makepath(distpath, "GTAGSROOT", NULL);
FILE *op = fopen(path, "w");
if (op == NULL)
die("cannot make file '%s'.", path);
fputs(cwdpath, op);
fputc('\n', op);
fclose(op);
}
/*
* (2) make help file
*/
message("[%s] (2) making help.html ...", now());
makehelp("help.html");
/*
* (#) load GPATH
*/
load_gpath(dbpath);
/*
* (3) make function entries (D/ and R/)
* MAKING TAG CACHE
*/
message("[%s] (3) making tag lists ...", now());
cache_open();
tim = statistics_time_start("Time of making tag lists");
func_total = makedupindex();
statistics_time_end(tim);
message("Total %d functions.", func_total);
/*
* (4) search index. (search.html)
*/
if (Fflag && fflag) {
message("[%s] (4) making search index ...", now());
makesearchindex("search.html");
}
{
STRBUF *defines = strbuf_open(0);
STRBUF *files = strbuf_open(0);
/*
* (5) make definition index (defines.html and defines/)
* PRODUCE @defines
*/
message("[%s] (5) making definition index ...", now());
tim = statistics_time_start("Time of making definition index");
func_total = makedefineindex("defines.html", func_total, defines);
statistics_time_end(tim);
message("Total %d functions.", func_total);
/*
* (6) make file index (files.html and files/)
* PRODUCE @files, %includes
*/
message("[%s] (6) making file index ...", now());
init_inc();
tim = statistics_time_start("Time of making file index");
file_total = makefileindex("files.html", files);
statistics_time_end(tim);
message("Total %d files.", file_total);
html_count += file_total;
/*
* (7) make call tree using cflow(1)'s output (cflow.html)
*/
if (call_file || callee_file) {
message("[%s] (7) making cflow index ...", now());
tim = statistics_time_start("Time of making cflow index");
if (call_file)
if (makecflowindex("call.html", call_file) < 0)
call_file = NULL;
if (callee_file)
if (makecflowindex("callee.html", callee_file) < 0)
callee_file = NULL;
statistics_time_end(tim);
}
/*
* [#] make include file index.
*/
message("[%s] (#) making include file index ...", now());
tim = statistics_time_start("Time of making include file index");
makeincludeindex();
statistics_time_end(tim);
/*
* [#] make a common part for mains.html and index.html
* USING @defines @files
*/
message("[%s] (#) making a common part ...", now());
index = makecommonpart(title, strbuf_value(defines), strbuf_value(files));
strbuf_close(defines);
strbuf_close(files);
}
/*
* (7)make index file (index.html)
*/
message("[%s] (7) making index file ...", now());
makeindex("index.html", title, index);
/*
* (8) make main index (mains.html)
*/
message("[%s] (8) making main index ...", now());
makemainindex("mains.html", index);
/*
* (9) make HTML files (SRCS/)
* USING TAG CACHE, %includes and anchor database.
*/
message("[%s] (9) making hypertext from source code ...", now());
tim = statistics_time_start("Time of making hypertext");
makehtml(file_total);
statistics_time_end(tim);
/*
* (10) rebuild script. (rebuild.sh)
*
* Don't grant execute permission to rebuild script.
*/
makerebuild("rebuild.sh");
if (chmod(makepath(distpath, "rebuild.sh", NULL), 0640) < 0)
die("cannot chmod rebuild script.");
/*
* (11) style sheet file (style.css)
*/
if (enable_xhtml) {
char src[MAXPATHLEN];
char dist[MAXPATHLEN];
snprintf(src, sizeof(src), "%s/gtags/style.css", datadir);
snprintf(dist, sizeof(dist), "%s/style.css", distpath);
copyfile(src, dist);
}
if (auto_completion || tree_view) {
char src[MAXPATHLEN];
char dist[MAXPATHLEN];
snprintf(src, sizeof(src), "%s/gtags/jquery", datadir);
snprintf(dist, sizeof(dist), "%s/js", distpath);
copydirectory(src, dist);
snprintf(src, sizeof(src), "%s/gtags/jquery/images", datadir);
snprintf(dist, sizeof(dist), "%s/js/images", distpath);
copydirectory(src, dist);
}
message("[%s] Done.", now());
if (vflag && (fflag || dynamic || auto_completion)) {
message("\n[Information]\n");
message(" o Htags was invoked with the -f, -c, -D or --auto-completion option. You should");
message(" start http server so that cgi-bin/*.cgi is executed as a CGI script.");
message("\n If you are using Apache, 'HTML/.htaccess' might be helpful for you.\n");
message(" Good luck!\n");
}
if (Iflag) {
char src[MAXPATHLEN];
char dist[MAXPATHLEN];
snprintf(src, sizeof(src), "%s/gtags/icons", datadir);
snprintf(dist, sizeof(dist), "%s/icons", distpath);
copydirectory(src, dist);
}
gpath_close();
/*
* Print statistics information.
*/
print_statistics(statistics);
clean();
return 0;
}
bool GadgetBeamWeapon::updateLogic()
{
if ( useActive() || usableWhen() > 0 )
return true; // early out if not ready to fire or currently in use...
if ( WidgetCast<NounShip>( parent() ) )
{
NounShip * pShip = (NounShip *)parent();
// turn on point defense if not on already...
if ( !pointDefense() && type() != WEAPON_BOMB && allowPointDefense() )
setPointDefense( true );
NounGame * pTarget = WidgetCast<NounGame>( pShip->commandTarget() );
if (! pTarget )
return true; // no current target
if ( pTarget != pShip->lastFireTarget() || !pShip->isWeaponsFree() )
return true; // can't hit target
if ( isFriend( pTarget ) )
return true; // don't attack friendly targets
if( WidgetCast<NounJumpGate>( pTarget )
|| WidgetCast<CargoResource>( pTarget ) )
return true; // don't attack jump gates or resources
if (! pTarget->canDamage( damageType() ) )
return true; // can't damage this target, so don't use this weapon
if ( type() == WEAPON_BOMB && WidgetCast<NounPlanet>( pTarget ) == NULL )
return true; // only use bomb weapons on planets..
if ( usable( pTarget, false ) )
pShip->useGadget( this, pTarget, false );
}
else if ( WidgetCast<StructureDefense>( parent() ) )
{
StructureDefense * pStructure = (StructureDefense *)parent();
if (! pStructure->active() )
return true;
NounPlanet * pPlanet = pStructure->planet();
if (! pPlanet )
return false;
Noun * pBestTarget = NULL;
float fBestRange = 0.0f;;
// look for incoming enemy projectiles, pick the best target
for(int j=0;j<pPlanet->contactCount();j++)
{
NounGame * pContact = WidgetCast<NounGame>( pPlanet->contact( j ) );
if ( pContact != NULL && pContact->enablePD() && !pPlanet->isFriend( pContact ) )
{
float fRange = (worldPosition() - pContact->worldPosition()).magnitude();
if ( (!pBestTarget || fRange < fBestRange) && usable( pContact, false )
&& !StructureDefense::isTargeted( pPlanet, pContact) )
{
pBestTarget = pContact;
fBestRange = fRange;
}
}
}
if ( pBestTarget )
{
// set the target now, so no other beam weapon tries to destroy the projectile
setTarget( pBestTarget );
// use the beam weapon on the projectile
pStructure->useGadget( pBestTarget, this );
return true;
}
for(int j=0;j<pPlanet->contactCount();j++)
{
NounShip * pShip = WidgetCast<NounShip>( pPlanet->contact( j ) );
if ( pShip != NULL && pPlanet->isEnemy( pShip ) )
{
float fRange = (worldPosition() - pShip->worldPosition()).magnitude();
if ( (!pBestTarget || fRange < fBestRange) && usable( pShip, false ) )
{
pBestTarget = pShip;
fBestRange = fRange;
}
}
}
if ( pBestTarget != NULL )
pStructure->useGadget( pBestTarget, this );
return true;
}
return false;
}
int
main(int argc, char **argv)
{
char dbpath[MAXPATHLEN];
char cwd[MAXPATHLEN];
STRBUF *sb = strbuf_open(0);
int optchar;
int option_index = 0;
STATISTICS_TIME *tim;
/*
* Setup GTAGSCONF and GTAGSLABEL environment variable
* according to the --gtagsconf and --gtagslabel option.
*/
preparse_options(argc, argv);
/*
* Get the project root directory.
*/
if (!vgetcwd(cwd, MAXPATHLEN))
die("cannot get current directory.");
canonpath(cwd);
/*
* Load configuration file.
*/
openconf(cwd);
configuration();
setenv_from_config();
{
char *env = getenv("GTAGS_OPTIONS");
if (env && *env)
argv = prepend_options(&argc, argv, env);
}
logging_arguments(argc, argv);
while ((optchar = getopt_long(argc, argv, "cd:f:iIn:oOqvwse", long_options, &option_index)) != EOF) {
switch (optchar) {
case 0:
/* already flags set */
break;
case OPT_CONFIG:
show_config = 1;
if (optarg)
config_name = optarg;
break;
case OPT_GTAGSCONF:
case OPT_GTAGSLABEL:
/* These options are already parsed in preparse_options() */
break;
case OPT_SINGLE_UPDATE:
iflag++;
single_update = optarg;
break;
case OPT_ACCEPT_DOTFILES:
set_accept_dotfiles();
break;
case 'c':
cflag++;
break;
case 'd':
dump_target = optarg;
break;
case 'f':
file_list = optarg;
break;
case 'i':
iflag++;
break;
case 'I':
Iflag++;
break;
case 'o':
/*
* Though the -o(--omit-gsyms) was removed, this code
* is left for compatibility.
*/
break;
case 'O':
Oflag++;
break;
case 'q':
qflag++;
setquiet();
break;
case 'w':
wflag++;
break;
case 'v':
vflag++;
setverbose();
break;
default:
usage();
break;
}
}
if (qflag)
vflag = 0;
if (show_version)
version(NULL, vflag);
if (show_help)
help();
argc -= optind;
argv += optind;
/* If dbpath is specified, -O(--objdir) option is ignored. */
if (argc > 0)
Oflag = 0;
if (show_config) {
openconf(setupdbpath(0) == 0 ? get_root() : NULL);
if (config_name)
printconf(config_name);
else
fprintf(stdout, "%s\n", getconfline());
exit(0);
} else if (dump_target) {
/*
* Dump a tag file.
*/
DBOP *dbop = NULL;
const char *dat = 0;
int is_gpath = 0;
if (!test("f", dump_target))
die("file '%s' not found.", dump_target);
if ((dbop = dbop_open(dump_target, 0, 0, DBOP_RAW)) == NULL)
die("file '%s' is not a tag file.", dump_target);
/*
* The file which has a NEXTKEY record is GPATH.
*/
if (dbop_get(dbop, NEXTKEY))
is_gpath = 1;
for (dat = dbop_first(dbop, NULL, NULL, 0); dat != NULL; dat = dbop_next(dbop)) {
const char *flag = is_gpath ? dbop_getflag(dbop) : "";
if (*flag)
printf("%s\t%s\t%s\n", dbop->lastkey, dat, flag);
else
printf("%s\t%s\n", dbop->lastkey, dat);
}
dbop_close(dbop);
exit(0);
} else if (Iflag) {
#define REQUIRED_MKID_VERSION "4.5"
char *p;
if (!usable("mkid"))
die("mkid not found.");
if (read_first_line("mkid --version", sb))
die("mkid cannot executed.");
p = strrchr(strbuf_value(sb), ' ');
if (p == NULL)
die("invalid version string of mkid: %s", strbuf_value(sb));
switch (check_version(p + 1, REQUIRED_MKID_VERSION)
#ifdef _WIN32
|| strcmp(p + 1, "3.2.99") == 0
#endif
) {
case 1:
break; /* OK */
case 0:
die("mkid version %s or later is required.", REQUIRED_MKID_VERSION);
default:
die("invalid version string of mkid: %s", strbuf_value(sb));
}
}
/*
* If 'gtags.files' exists, use it as a file list.
* If the file_list other than "-" is given, it must be readable file.
*/
if (file_list == NULL && test("f", GTAGSFILES))
file_list = GTAGSFILES;
if (file_list && strcmp(file_list, "-")) {
if (test("d", file_list))
die("'%s' is a directory.", file_list);
else if (!test("f", file_list))
die("'%s' not found.", file_list);
else if (!test("r", file_list))
die("'%s' is not readable.", file_list);
}
/*
* Regularize the path name for single updating (--single-update).
*/
if (single_update) {
static char regular_path_name[MAXPATHLEN];
char *p = single_update;
if (!test("f", p))
die("'%s' not found.", p);
#if _WIN32 || __DJGPP__
for (; *p; p++)
if (*p == '\\')
*p = '/';
p = single_update;
#define LOCATEFLAG MATCH_AT_FIRST|IGNORE_CASE
#else
#define LOCATEFLAG MATCH_AT_FIRST
#endif
if (isabspath(p)) {
char *q = locatestring(p, cwd, LOCATEFLAG);
if (q && *q == '/')
snprintf(regular_path_name, MAXPATHLEN, "./%s", q + 1);
else
die("path '%s' is out of the project.", p);
} else {
if (p[0] == '.' && p[1] == '/')
snprintf(regular_path_name, MAXPATHLEN, "%s", p);
else
snprintf(regular_path_name, MAXPATHLEN, "./%s", p);
}
single_update = regular_path_name;
}
/*
* Decide directory (dbpath) in which gtags make tag files.
*
* Gtags create tag files at current directory by default.
* If dbpath is specified as an argument then use it.
* If the -i option specified and both GTAGS and GRTAGS exists
* at one of the candidate directories then gtags use existing
* tag files.
*/
if (iflag) {
if (argc > 0)
realpath(*argv, dbpath);
else if (!gtagsexist(cwd, dbpath, MAXPATHLEN, vflag))
strlimcpy(dbpath, cwd, sizeof(dbpath));
} else {
if (argc > 0)
realpath(*argv, dbpath);
else if (Oflag) {
char *objdir = getobjdir(cwd, vflag);
if (objdir == NULL)
die("Objdir not found.");
strlimcpy(dbpath, objdir, sizeof(dbpath));
} else
strlimcpy(dbpath, cwd, sizeof(dbpath));
}
if (iflag && (!test("f", makepath(dbpath, dbname(GTAGS), NULL)) ||
!test("f", makepath(dbpath, dbname(GRTAGS), NULL)) ||
!test("f", makepath(dbpath, dbname(GPATH), NULL)))) {
if (wflag)
warning("GTAGS, GRTAGS or GPATH not found. -i option ignored.");
iflag = 0;
}
if (!test("d", dbpath))
die("directory '%s' not found.", dbpath);
if (vflag)
fprintf(stderr, "[%s] Gtags started.\n", now());
/*
* initialize parser.
*/
if (vflag && gtags_parser)
fprintf(stderr, " Using plug-in parser.\n");
parser_init(langmap, gtags_parser);
if (vflag && file_list)
fprintf(stderr, " Using '%s' as a file list.\n", file_list);
/*
* Start statistics.
*/
init_statistics();
/*
* incremental update.
*/
if (iflag) {
/*
* Version check. If existing tag files are old enough
* gtagsopen() abort with error message.
*/
GTOP *gtop = gtags_open(dbpath, cwd, GTAGS, GTAGS_MODIFY, 0);
gtags_close(gtop);
/*
* GPATH is needed for incremental updating.
* Gtags check whether or not GPATH exist, since it may be
* removed by mistake.
*/
if (!test("f", makepath(dbpath, dbname(GPATH), NULL)))
die("Old version tag file found. Please remake it.");
(void)incremental(dbpath, cwd);
print_statistics(statistics);
exit(0);
}
/*
* create GTAGS and GRTAGS
*/
createtags(dbpath, cwd);
/*
* create idutils index.
*/
if (Iflag) {
FILE *op;
GFIND *gp;
const char *path;
tim = statistics_time_start("Time of creating ID");
if (vflag)
fprintf(stderr, "[%s] Creating indexes for idutils.\n", now());
strbuf_reset(sb);
/*
* Since idutils stores the value of PWD in ID file, we need to
* force idutils to follow our style.
*/
#if _WIN32 || __DJGPP__
strbuf_puts(sb, "mkid --files0-from=-");
#else
strbuf_sprintf(sb, "PWD=%s mkid --files0-from=-", quote_shell(cwd));
#endif
if (vflag)
strbuf_puts(sb, " -v");
strbuf_sprintf(sb, " --file=%s/ID", quote_shell(dbpath));
if (vflag) {
#ifdef __DJGPP__
if (is_unixy()) /* test for 4DOS as well? */
#endif
strbuf_puts(sb, " 1>&2");
} else {
strbuf_puts(sb, " >" NULL_DEVICE);
#ifdef __DJGPP__
if (is_unixy()) /* test for 4DOS as well? */
#endif
strbuf_puts(sb, " 2>&1");
}
if (debug)
fprintf(stderr, "executing mkid like: %s\n", strbuf_value(sb));
op = popen(strbuf_value(sb), "w");
if (op == NULL)
die("cannot execute '%s'.", strbuf_value(sb));
gp = gfind_open(dbpath, NULL, GPATH_BOTH);
while ((path = gfind_read(gp)) != NULL) {
fputs(path, op);
fputc('\0', op);
}
gfind_close(gp);
if (pclose(op) != 0)
die("terminated abnormally '%s' (errno = %d).", strbuf_value(sb), errno);
if (test("f", makepath(dbpath, "ID", NULL)))
if (chmod(makepath(dbpath, "ID", NULL), 0644) < 0)
die("cannot chmod ID file.");
statistics_time_end(tim);
}
if (vflag)
fprintf(stderr, "[%s] Done.\n", now());
closeconf();
strbuf_close(sb);
print_statistics(statistics);
return 0;
}
int
main(int argc, char **argv)
{
char dbpath[MAXPATHLEN];
char cwd[MAXPATHLEN];
STRBUF *sb = strbuf_open(0);
int optchar;
int option_index = 0;
STATISTICS_TIME *tim;
while ((optchar = getopt_long(argc, argv, "cd:f:iuIn:oOqvwse", long_options, &option_index)) != EOF) {
switch (optchar) {
case 0:
/* already flags set */
break;
case OPT_CONFIG:
show_config = 1;
if (optarg)
config_name = optarg;
break;
case OPT_GTAGSCONF:
gtagsconf = optarg;
break;
case OPT_GTAGSLABEL:
gtagslabel = optarg;
break;
case OPT_PATH:
do_path = 1;
if (!strcmp("absolute", optarg))
convert_type = PATH_ABSOLUTE;
else if (!strcmp("relative", optarg))
convert_type = PATH_RELATIVE;
else if (!strcmp("through", optarg))
convert_type = PATH_THROUGH;
else
die("Unknown path type.");
break;
case OPT_SINGLE_UPDATE:
iflag++;
single_update = optarg;
break;
case OPT_ENCODE_PATH:
if (strlen(optarg) > 255)
die("too many encode chars.");
if (strchr(optarg, '/') || strchr(optarg, '.'))
die("cannot encode '/' and '.' in the path.");
set_encode_chars((unsigned char *)optarg);
break;
case 'c':
cflag++;
break;
case 'd':
dump_target = optarg;
break;
case 'f':
file_list = optarg;
break;
case 'i':
iflag++;
break;
case 'u':
uflag++;
iflag++;
break;
case 'I':
Iflag++;
break;
case 'o':
/*
* Though the -o(--omit-gsyms) was removed, this code
* is left for compatibility.
*/
break;
case 'O':
Oflag++;
break;
case 'q':
qflag++;
setquiet();
break;
case 'w':
wflag++;
break;
case 'v':
vflag++;
setverbose();
break;
default:
usage();
break;
}
}
if (gtagsconf) {
char path[MAXPATHLEN];
if (realpath(gtagsconf, path) == NULL)
die("%s not found.", gtagsconf);
set_env("GTAGSCONF", path);
}
if (gtagslabel) {
set_env("GTAGSLABEL", gtagslabel);
}
if (qflag)
vflag = 0;
if (show_version)
version(NULL, vflag);
if (show_help)
help();
argc -= optind;
argv += optind;
/* If dbpath is specified, -O(--objdir) option is ignored. */
if (argc > 0)
Oflag = 0;
if (show_config) {
if (config_name)
printconf(config_name);
else
fprintf(stdout, "%s\n", getconfline());
exit(0);
} else if (do_path) {
/*
* This is the main body of path filter.
* This code extract path name from tag line and
* replace it with the relative or the absolute path name.
*
* By default, if we are in src/ directory, the output
* should be converted like follws:
*
* main 10 ./src/main.c main(argc, argv)\n
* main 22 ./libc/func.c main(argc, argv)\n
* v
* main 10 main.c main(argc, argv)\n
* main 22 ../libc/func.c main(argc, argv)\n
*
* Similarly, the --path=absolute option specified, then
* v
* main 10 /prj/xxx/src/main.c main(argc, argv)\n
* main 22 /prj/xxx/libc/func.c main(argc, argv)\n
*/
STRBUF *ib = strbuf_open(MAXBUFLEN);
CONVERT *cv;
char *ctags_x;
if (argc < 3)
die("gtags --path: 3 arguments needed.");
cv = convert_open(convert_type, FORMAT_CTAGS_X, argv[0], argv[1], argv[2], stdout);
while ((ctags_x = strbuf_fgets(ib, stdin, STRBUF_NOCRLF)) != NULL)
convert_put(cv, ctags_x);
convert_close(cv);
strbuf_close(ib);
exit(0);
} else if (dump_target) {
/*
* Dump a tag file.
*/
DBOP *dbop = NULL;
const char *dat = 0;
int is_gpath = 0;
char* target_file = NULL;
if (!test("f", dump_target)) {
target_file = strchr(dump_target, ':');
if (target_file == NULL)
die("file '%s' not found", dump_target);
*target_file++ = 0; //move to the next char, which starts the target file.
if (!test("f", dump_target)) {
die("file '%s' not found.", dump_target);
}
}
if ((dbop = dbop_open(dump_target, 0, 0, DBOP_RAW)) == NULL)
die("file '%s' is not a tag file.", dump_target);
/*
* The file which has a NEXTKEY record is GPATH.
*/
if (dbop_get(dbop, NEXTKEY))
is_gpath = 1;
if (target_file && !is_gpath) {
die("dump target_file can only be used with GPATH");
}
if (target_file) {
dat = dbop_get(dbop, target_file);
if (dat == NULL) {
die("target_file %s not found in GPATH", target_file);
}
time_t t = gpath_mtime(dbop, target_file);
printf("%d\n", t);
} else {
for (dat = dbop_first(dbop, NULL, NULL, 0); dat != NULL; dat = dbop_next(dbop)) {
const char *flag = is_gpath ? dbop_getflag(dbop) : "";
if (*flag)
if (is_gpath) {
time_t t = gpath_mtime(dbop, dbop->lastkey);
printf("%s\t%s\t%s\t%s\n", dbop->lastkey, dat, flag, ctime(&t));
} else
printf("%s\t%s\t%s\n", dbop->lastkey, dat, flag);
else
printf("%s\t%s\n", dbop->lastkey, dat);
}
}
dbop_close(dbop);
exit(0);
} else if (Iflag) {
if (!usable("mkid"))
die("mkid not found.");
}
/*
* If 'gtags.files' exists, use it as a file list.
* If the file_list other than "-" is given, it must be readable file.
*/
if (file_list == NULL && test("f", GTAGSFILES))
file_list = GTAGSFILES;
if (file_list && strcmp(file_list, "-")) {
if (test("d", file_list))
die("'%s' is a directory.", file_list);
else if (!test("f", file_list))
die("'%s' not found.", file_list);
else if (!test("r", file_list))
die("'%s' is not readable.", file_list);
}
/*
* Regularize the path name for single updating (--single-update).
*/
if (single_update) {
static char regular_path_name[MAXPATHLEN];
char *p = single_update;
if (!test("f", p))
die("'%s' not found.", p);
if (isabspath(p))
die("--single-update requires relative path name.");
if (!(p[0] == '.' && p[1] == '/')) {
snprintf(regular_path_name, MAXPATHLEN, "./%s", p);
p = regular_path_name;
}
single_update = p;
}
if (!getcwd(cwd, MAXPATHLEN))
die("cannot get current directory.");
canonpath(cwd);
/*
* Decide directory (dbpath) in which gtags make tag files.
*
* Gtags create tag files at current directory by default.
* If dbpath is specified as an argument then use it.
* If the -i option specified and both GTAGS and GRTAGS exists
* at one of the candidate directories then gtags use existing
* tag files.
*/
if (iflag) {
if (argc > 0)
realpath(*argv, dbpath);
else if (!gtagsexist(cwd, dbpath, MAXPATHLEN, vflag))
strlimcpy(dbpath, cwd, sizeof(dbpath));
} else {
if (argc > 0)
realpath(*argv, dbpath);
else if (Oflag) {
char *objdir = getobjdir(cwd, vflag);
if (objdir == NULL)
die("Objdir not found.");
strlimcpy(dbpath, objdir, sizeof(dbpath));
} else
strlimcpy(dbpath, cwd, sizeof(dbpath));
}
if (iflag && (!test("f", makepath(dbpath, dbname(GTAGS), NULL)) ||
!test("f", makepath(dbpath, dbname(GRTAGS), NULL)) ||
!test("f", makepath(dbpath, dbname(GPATH), NULL)))) {
if (wflag)
warning("GTAGS, GRTAGS or GPATH not found. -i option ignored.");
iflag = 0;
}
if (!test("d", dbpath))
die("directory '%s' not found.", dbpath);
if (vflag)
fprintf(stderr, "[%s] Gtags started.\n", now());
/*
* load configuration file.
*/
openconf();
if (getconfb("extractmethod"))
extractmethod = 1;
strbuf_reset(sb);
if (getconfs("langmap", sb))
langmap = check_strdup(strbuf_value(sb));
strbuf_reset(sb);
if (getconfs("gtags_parser", sb))
gtags_parser = check_strdup(strbuf_value(sb));
/*
* initialize parser.
*/
if (vflag && gtags_parser)
fprintf(stderr, " Using plug-in parser.\n");
parser_init(langmap, gtags_parser);
if (vflag && file_list)
fprintf(stderr, " Using '%s' as a file list.\n", file_list);
/*
* Start statistics.
*/
init_statistics();
/*
* incremental update.
*/
if (iflag) {
/*
* Version check. If existing tag files are old enough
* gtagsopen() abort with error message.
*/
GTOP *gtop = gtags_open(dbpath, cwd, GTAGS, GTAGS_MODIFY, 0);
gtags_close(gtop);
/*
* GPATH is needed for incremental updating.
* Gtags check whether or not GPATH exist, since it may be
* removed by mistake.
*/
if (!test("f", makepath(dbpath, dbname(GPATH), NULL)))
die("Old version tag file found. Please remake it.");
(void)incremental(dbpath, cwd);
print_statistics(statistics);
exit(0);
}
/*
* create GTAGS and GRTAGS
*/
createtags(dbpath, cwd);
/*
* create idutils index.
*/
if (Iflag) {
tim = statistics_time_start("Time of creating ID");
if (vflag)
fprintf(stderr, "[%s] Creating indexes for idutils.\n", now());
strbuf_reset(sb);
strbuf_puts(sb, "mkid");
if (vflag)
strbuf_puts(sb, " -v");
strbuf_sprintf(sb, " --file='%s/ID'", dbpath);
if (vflag) {
#ifdef __DJGPP__
if (is_unixy()) /* test for 4DOS as well? */
#endif
strbuf_puts(sb, " 1>&2");
} else {
strbuf_puts(sb, " >/dev/null");
}
if (debug)
fprintf(stderr, "executing mkid like: %s\n", strbuf_value(sb));
if (system(strbuf_value(sb)))
die("mkid failed: %s", strbuf_value(sb));
if (chmod(makepath(dbpath, "ID", NULL), 0644) < 0)
die("cannot chmod ID file.");
statistics_time_end(tim);
}
if (vflag)
fprintf(stderr, "[%s] Done.\n", now());
closeconf();
strbuf_close(sb);
print_statistics(statistics);
return 0;
}
int
main(int argc, char **argv)
{
const char *av = NULL;
int db;
int optchar;
int option_index = 0;
int status = 0;
/*
* get path of following directories.
* o current directory
* o root of source tree
* o dbpath directory
*
* if GTAGS not found, exit with an error message.
*/
status = setupdbpath(0);
if (status == 0) {
cwd = get_cwd();
root = get_root();
dbpath = get_dbpath();
}
/*
* Setup GTAGSCONF and GTAGSLABEL environment variable
* according to the --gtagsconf and --gtagslabel option.
*/
preparse_options(argc, argv);
/*
* Open configuration file.
*/
openconf(root);
setenv_from_config();
logging_arguments(argc, argv);
while ((optchar = getopt_long(argc, argv, "acde:EifFgGIlL:MnoOpPqrsS:tTuvVx", long_options, &option_index)) != EOF) {
switch (optchar) {
case 0:
break;
case 'a':
aflag++;
break;
case 'c':
cflag++;
setcom(optchar);
break;
case 'd':
dflag++;
break;
case 'e':
av = optarg;
break;
case 'E':
Gflag = 0;
break;
case 'f':
fflag++;
xflag++;
setcom(optchar);
break;
case 'F':
Tflag = 0;
break;
case 'g':
gflag++;
setcom(optchar);
break;
case 'G':
Gflag++;
break;
case 'i':
iflag++;
break;
case 'I':
Iflag++;
setcom(optchar);
break;
case 'l':
Sflag++;
scope = ".";
break;
case 'L':
file_list = optarg;
break;
case 'M':
Mflag++;
iflag = 0;
break;
case 'n':
nflag++;
if (optarg) {
if (!strcmp(optarg, "sort"))
nofilter |= SORT_FILTER;
else if (!strcmp(optarg, "path"))
nofilter |= PATH_FILTER;
} else {
nofilter = BOTH_FILTER;
}
break;
case 'o':
oflag++;
break;
case 'O':
Oflag++;
break;
case 'p':
pflag++;
setcom(optchar);
break;
case 'P':
Pflag++;
setcom(optchar);
break;
case 'q':
qflag++;
setquiet();
break;
case 'r':
rflag++;
break;
case 's':
sflag++;
break;
case 'S':
Sflag++;
scope = optarg;
break;
case 't':
tflag++;
break;
case 'T':
Tflag++;
break;
case 'u':
uflag++;
setcom(optchar);
break;
case 'v':
vflag++;
setverbose();
break;
case 'V':
Vflag++;
break;
case 'x':
xflag++;
break;
case OPT_USE_COLOR:
if (optarg) {
if (!strcmp(optarg, "never"))
use_color = 0;
else if (!strcmp(optarg, "always"))
use_color = 1;
else if (!strcmp(optarg, "auto"))
use_color = 2;
else
die_with_code(2, "unknown color type.");
} else {
use_color = 2;
}
break;
case OPT_ENCODE_PATH:
encode_chars = optarg;
break;
case OPT_FROM_HERE:
{
char *p = optarg;
const char *usage = "usage: global --from-here=lineno:path.";
context_lineno = p;
while (*p && isdigit(*p))
p++;
if (*p != ':')
die_with_code(2, usage);
*p++ = '\0';
if (!*p)
die_with_code(2, usage);
context_file = p;
}
break;
case OPT_GTAGSCONF:
case OPT_GTAGSLABEL:
/* These options are already parsed in preparse_options() */
break;
case OPT_MATCH_PART:
if (!strcmp(optarg, "first"))
match_part = MATCH_PART_FIRST;
else if (!strcmp(optarg, "last"))
match_part = MATCH_PART_LAST;
else if (!strcmp(optarg, "all"))
match_part = MATCH_PART_ALL;
else
die_with_code(2, "unknown part type for the --match-part option.");
break;
case OPT_PATH_CONVERT:
do_path = 1;
if (!strcmp("absolute", optarg))
convert_type = PATH_ABSOLUTE;
else if (!strcmp("relative", optarg))
convert_type = PATH_RELATIVE;
else if (!strcmp("through", optarg))
convert_type = PATH_THROUGH;
else
die("Unknown path type.");
break;
case OPT_PATH_STYLE:
path_style = optarg;
break;
case OPT_RESULT:
if (!strcmp(optarg, "ctags-x"))
format = FORMAT_CTAGS_X;
else if (!strcmp(optarg, "ctags-xid"))
format = FORMAT_CTAGS_XID;
else if (!strcmp(optarg, "ctags"))
format = FORMAT_CTAGS;
else if (!strcmp(optarg, "ctags-mod"))
format = FORMAT_CTAGS_MOD;
else if (!strcmp(optarg, "path"))
format = FORMAT_PATH;
else if (!strcmp(optarg, "grep"))
format = FORMAT_GREP;
else if (!strcmp(optarg, "cscope"))
format = FORMAT_CSCOPE;
else
die_with_code(2, "unknown format type for the --result option.");
break;
case OPT_SINGLE_UPDATE:
single_update = optarg;
break;
default:
usage();
break;
}
}
if (qflag)
vflag = 0;
if (show_version)
version(av, vflag);
if (show_help)
help();
if (dbpath == NULL)
die_with_code(-status, gtags_dbpath_error);
/*
* decide format.
* The --result option is given to priority more than the -t and -x option.
*/
if (format == 0) {
if (tflag) { /* ctags format */
format = FORMAT_CTAGS;
} else if (xflag) { /* print details */
format = FORMAT_CTAGS_X;
} else { /* print just a file name */
format = FORMAT_PATH;
}
}
/*
* GTAGSBLANKENCODE will be used in less(1).
*/
switch (format) {
case FORMAT_CTAGS_X:
case FORMAT_CTAGS_XID:
if (encode_chars == NULL && getenv("GTAGSBLANKENCODE"))
encode_chars = " \t";
break;
}
if (encode_chars) {
if (strlen(encode_chars) > 255)
die("too many encode chars.");
if (strchr(encode_chars, '/') || strchr(encode_chars, '.'))
warning("cannot encode '/' and '.' in the path. Ignored.");
set_encode_chars((unsigned char *)encode_chars);
}
if (getenv("GTAGSTHROUGH"))
Tflag++;
if (use_color) {
#if defined(_WIN32) && !defined(__CYGWIN__)
if (!(getenv("ANSICON") || LoadLibrary("ANSI32.dll")) && use_color == 2)
use_color = 0;
#endif
if (use_color == 2 && !isatty(1))
use_color = 0;
if (Vflag)
use_color = 0;
}
argc -= optind;
argv += optind;
/*
* Path filter
*/
if (do_path) {
/*
* This code is needed for globash.rc.
* This code extract path name from tag line and
* replace it with the relative or the absolute path name.
*
* By default, if we are in src/ directory, the output
* should be converted like follows:
*
* main 10 ./src/main.c main(argc, argv)\n
* main 22 ./libc/func.c main(argc, argv)\n
* v
* main 10 main.c main(argc, argv)\n
* main 22 ../libc/func.c main(argc, argv)\n
*
* Similarly, the --path-convert=absolute option specified, then
* v
* main 10 /prj/xxx/src/main.c main(argc, argv)\n
* main 22 /prj/xxx/libc/func.c main(argc, argv)\n
*/
STRBUF *ib = strbuf_open(MAXBUFLEN);
CONVERT *cv;
char *ctags_x;
if (argc < 3)
die("global --path-convert: 3 arguments needed.");
cv = convert_open(convert_type, FORMAT_CTAGS_X, argv[0], argv[1], argv[2], stdout, NOTAGS);
while ((ctags_x = strbuf_fgets(ib, stdin, STRBUF_NOCRLF)) != NULL)
convert_put(cv, ctags_x);
convert_close(cv);
strbuf_close(ib);
exit(0);
}
/*
* At first, we pickup pattern from -e option. If it is not found
* then use argument which is not option.
*/
if (!av) {
av = *argv;
/*
* global -g pattern [files ...]
* av argv
*/
if (gflag && av)
argv++;
}
if (single_update) {
if (command == 0) {
uflag++;
command = 'u';
} else if (command != 'u') {
; /* ignored */
}
}
/*
* only -c, -u, -P and -p allows no argument.
*/
if (!av) {
switch (command) {
case 'c':
case 'u':
case 'p':
case 'P':
break;
case 'f':
if (file_list)
break;
default:
usage();
break;
}
}
/*
* -u and -p cannot have any arguments.
*/
if (av) {
switch (command) {
case 'u':
case 'p':
usage();
default:
break;
}
}
if (tflag)
xflag = 0;
if (nflag > 1)
nosource = 1; /* to keep compatibility */
if (print0)
set_print0();
if (cflag && match_part == 0)
match_part = MATCH_PART_ALL;
/*
* remove leading blanks.
*/
if (!Iflag && !gflag && av)
for (; *av == ' ' || *av == '\t'; av++)
;
if (cflag && !Pflag && av && isregex(av))
die_with_code(2, "only name char is allowed with -c option.");
/*
* print dbpath or rootdir.
*/
if (pflag) {
fprintf(stdout, "%s\n", (rflag) ? root : dbpath);
exit(0);
}
/*
* incremental update of tag files.
*/
if (uflag) {
STRBUF *sb = strbuf_open(0);
char *gtags_path = usable("gtags");
if (!gtags_path)
die("gtags command not found.");
if (chdir(root) < 0)
die("cannot change directory to '%s'.", root);
#if defined(_WIN32) && !defined(__CYGWIN__)
/*
* Get around CMD.EXE's weird quoting rules by sticking another
* perceived whitespace in front (also works with Take Command).
*/
strbuf_putc(sb, ';');
#endif
strbuf_puts(sb, quote_shell(gtags_path));
strbuf_puts(sb, " -i");
if (vflag)
strbuf_puts(sb, " -v");
if (single_update) {
if (!isabspath(single_update)) {
static char regular_path_name[MAXPATHLEN];
if (rel2abs(single_update, cwd, regular_path_name, sizeof(regular_path_name)) == NULL)
die("rel2abs failed.");
single_update = regular_path_name;
}
strbuf_puts(sb, " --single-update ");
strbuf_puts(sb, quote_shell(single_update));
}
strbuf_putc(sb, ' ');
strbuf_puts(sb, quote_shell(dbpath));
if (system(strbuf_value(sb)))
exit(1);
strbuf_close(sb);
exit(0);
}
/*
* decide tag type.
*/
if (context_file) {
if (isregex(av))
die_with_code(2, "regular expression is not allowed with the --from-here option.");
db = decide_tag_by_context(av, context_file, atoi(context_lineno));
} else {
if (dflag)
db = GTAGS;
else if (rflag && sflag)
db = GRTAGS + GSYMS;
else
db = (rflag) ? GRTAGS : ((sflag) ? GSYMS : GTAGS);
}
/*
* complete function name
*/
if (cflag) {
if (Iflag)
completion_idutils(dbpath, root, av);
else if (Pflag)
completion_path(dbpath, av);
else
completion(dbpath, root, av, db);
exit(0);
}
/*
* make local prefix.
* local prefix must starts with './' and ends with '/'.
*/
if (Sflag) {
STRBUF *sb = strbuf_open(0);
static char buf[MAXPATHLEN];
const char *path = scope;
/*
* normalize the path of scope directory.
*/
if (!test("d", path))
die("'%s' not found or not a directory.", scope);
if (!isabspath(path))
path = makepath(cwd, path, NULL);
if (realpath(path, buf) == NULL)
die("cannot get real path of '%s'.", scope);
if (!in_the_project(buf))
die("'%s' is out of the source project.", scope);
scope = buf;
/*
* make local prefix.
*/
strbuf_putc(sb, '.');
if (strcmp(root, scope) != 0) {
const char *p = scope + strlen(root);
if (*p != '/')
strbuf_putc(sb, '/');
strbuf_puts(sb, p);
}
strbuf_putc(sb, '/');
localprefix = check_strdup(strbuf_value(sb));
strbuf_close(sb);
#ifdef DEBUG
fprintf(stderr, "root=%s\n", root);
fprintf(stderr, "cwd=%s\n", cwd);
fprintf(stderr, "localprefix=%s\n", localprefix);
#endif
}
/*
* convert the file-list path into an absolute path.
*/
if (file_list && strcmp(file_list, "-") && !isabspath(file_list)) {
static char buf[MAXPATHLEN];
if (realpath(file_list, buf) == NULL)
die("'%s' not found.", file_list);
file_list = buf;
}
/*
* decide path conversion type.
*/
if (nofilter & PATH_FILTER)
type = PATH_THROUGH;
else if (aflag)
type = PATH_ABSOLUTE;
else
type = PATH_RELATIVE;
if (path_style) {
if (!strcmp(path_style, "relative"))
type = PATH_RELATIVE;
else if (!strcmp(path_style, "absolute"))
type = PATH_ABSOLUTE;
else if (!strcmp(path_style, "through"))
type = PATH_THROUGH;
else if (!strcmp(path_style, "shorter"))
type = PATH_SHORTER;
else if (!strcmp(path_style, "abslib")) {
type = PATH_RELATIVE;
abslib++;
} else
die("invalid path style.");
}
/*
* exec lid(idutils).
*/
if (Iflag) {
chdir(root);
idutils(av, dbpath);
}
/*
* search pattern (regular expression).
*/
else if (gflag) {
chdir(root);
grep(av, argv, dbpath);
}
/*
* locate paths including the pattern.
*/
else if (Pflag) {
chdir(root);
pathlist(av, dbpath);
}
/*
* parse source files.
*/
else if (fflag) {
chdir(root);
parsefile(argv, cwd, root, dbpath, db);
}
/*
* tag search.
*/
else {
tagsearch(av, cwd, root, dbpath, db);
}
return 0;
}
/*
* idutils: lid(idutils) pattern
*
* i) pattern POSIX regular expression
* i) dbpath GTAGS directory
*/
void
idutils(const char *pattern, const char *dbpath)
{
FILE *ip;
CONVERT *cv;
STRBUF *ib = strbuf_open(0);
char encoded_pattern[IDENTLEN];
char path[MAXPATHLEN];
const char *lid;
int linenum, count;
char *p, *q, *grep;
lid = usable("lid");
if (!lid)
die("lid(idutils) not found.");
/*
* convert spaces into %FF format.
*/
encode(encoded_pattern, sizeof(encoded_pattern), pattern);
/*
* make lid command line.
* Invoke lid with the --result=grep option to generate grep format.
*/
strbuf_puts(ib, lid);
strbuf_sprintf(ib, " --file='%s/ID'", dbpath);
strbuf_puts(ib, " --separator=newline");
if (format == FORMAT_PATH)
strbuf_puts(ib, " --result=filenames --key=none");
else
strbuf_puts(ib, " --result=grep");
if (iflag)
strbuf_puts(ib, " --ignore-case");
strbuf_putc(ib, ' ');
strbuf_puts(ib, quote_string(pattern));
if (debug)
fprintf(stderr, "idutils: %s\n", strbuf_value(ib));
if (!(ip = popen(strbuf_value(ib), "r")))
die("cannot execute '%s'.", strbuf_value(ib));
cv = convert_open(type, format, root, cwd, dbpath, stdout);
count = 0;
strcpy(path, "./");
while ((grep = strbuf_fgets(ib, ip, STRBUF_NOCRLF)) != NULL) {
q = path + 2;
/* extract path name */
if (*grep == '/')
die("The path in the output of lid is assumed absolute. '%s'", grep);
p = grep;
while (*p && *p != ':')
*q++ = *p++;
*q = '\0';
if ((xflag || tflag) && !*p)
die("invalid lid(idutils) output format(1). '%s'", grep);
p++;
if (lflag) {
if (!locatestring(path, localprefix, MATCH_AT_FIRST))
continue;
}
count++;
switch (format) {
case FORMAT_PATH:
convert_put_path(cv, path);
break;
default:
/* extract line number */
while (*p && isspace(*p))
p++;
linenum = 0;
for (linenum = 0; *p && isdigit(*p); linenum = linenum * 10 + (*p++ - '0'))
;
if (*p != ':')
die("invalid lid(idutils) output format(2). '%s'", grep);
if (linenum <= 0)
die("invalid lid(idutils) output format(3). '%s'", grep);
p++;
/*
* print out.
*/
convert_put_using(cv, encoded_pattern, path, linenum, p, NULL);
break;
}
}
if (pclose(ip) < 0)
die("terminated abnormally.");
convert_close(cv);
strbuf_close(ib);
if (vflag) {
print_count(count);
fprintf(stderr, " (using idutils index in '%s').\n", dbpath);
}
}