/*
* Copyright (c) 2005, 2006, 2010, 2014
* Tama Communications Corporation
*
* This file is part of GNU GLOBAL.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see .
*/
#ifdef HAVE_CONFIG_H
#include
#endif
#include
#include
#ifdef STDC_HEADERS
#include
#endif
#ifdef HAVE_STRING_H
#include
#else
#include
#endif
#include "abs2rel.h"
#include "char.h"
#include "checkalloc.h"
#include "die.h"
#include "encodepath.h"
#include "format.h"
#include "gparam.h"
#include "gpathop.h"
#include "gtagsop.h"
#include "rewrite.h"
#include "strbuf.h"
#include "strlimcpy.h"
#include "convert.h"
static int debug = 0;
static int flags;
/**
* This module converts records before output.
* The converting includes the followings:
*
* 1. constructing format (-x, -t, --result)
* 2. converting path style (-a, --path-style)
* 3. inserting escape sequences for coloring (--color)
*/
/**
* coloring support using ANSI escape sequence (SGR)
*/
#define ESC '\033'
#define EOE 'm'
#define DEFAULT_COLOR "01;31"
static REWRITE *rewrite;
static char last_pattern[IDENTLEN];
static int locked;
static int (*code_fputs)(const char *s, FILE *op) = fputs;
/**
* set output flags.
*/
void
set_convert_flags(int a_flags)
{
flags = a_flags;
}
/**
* fputs with coloring.
*/
static int
color_code_fputs(const char *string, FILE *op)
{
return fputs(rewrite_string(rewrite, string, 0), op);
}
/**
* set_color_method: setup ANSI escape sequence (SGR).
*/
static void
set_color_method(void)
{
STATIC_STRBUF(sb);
const char *sgr = DEFAULT_COLOR;
const char *col = getenv("GREP_COLOR");
int len;
if (col != NULL)
sgr = col;
len = strlen(sgr);
col = getenv("GREP_COLORS");
if (col != NULL) {
const char *part = strstr(col, "mt=");
if (part == NULL)
part = strstr(col, "ms=");
if (part != NULL) {
const char *sep = strchr(part, ':');
if (sep == NULL)
sep = strchr(part, '\0');
if (sep[-1] != '=') {
sgr = part + 3;
len = sep - sgr;
}
}
}
strbuf_clear(sb);
/* begin coloring */
strbuf_putc(sb, ESC);
strbuf_putc(sb, '[');
strbuf_nputs(sb, sgr, len);
strbuf_putc(sb, EOE);
/* tag name */
strbuf_putc(sb, '&');
/* end coloring */
strbuf_putc(sb, ESC);
strbuf_putc(sb, '[');
strbuf_putc(sb, EOE);
if (rewrite)
rewrite_close(rewrite);
rewrite = rewrite_open(NULL, strbuf_value(sb), 0);
locked = 0;
last_pattern[0] = '\0';
}
/**
* set_color_tag: construct regular expression for coloring tag.
*
* You should not call this function when locked == true.
*/
static void
set_color_tag(const char *pattern)
{
STATIC_STRBUF(sb);
int rewrite_flags = 0;
if (rewrite == NULL)
die("set_color_tag: impossible.");
if (pattern == NULL || !strcmp(pattern, last_pattern))
return; /* nothing to do */
strlimcpy(last_pattern, pattern, sizeof(last_pattern));
strbuf_clear(sb);
if (flags & CONVERT_IDUTILS) {
/*
* refuse '.*' because it brings confused output.
*/
if (!strcmp(pattern, ".*") ||
!strcmp(pattern, "^.*") ||
!strcmp(pattern, ".*$") ||
!strcmp(pattern, "^.*$"))
{
rewrite_cancel(rewrite);
locked = 1;
return;
}
/*
* Though color support for the -I command is far
* from perfection, it works in almost case.
*/
strbuf_puts(sb, "\\b");
if (isregex(pattern)) {
int len = strlen(pattern);
int inclass, quote, dollar, i;
#define TOKEN_CHARS "[A-Za-z_0-9]"
inclass = quote = dollar = i = 0;
if (*pattern == '^') {
i = 1;
} else {
strbuf_puts(sb, TOKEN_CHARS);
strbuf_putc(sb, '*');
}
for (; i < len; i++) {
int c = pattern[i];
if (quote) {
quote = 0;
strbuf_putc(sb, c);
} else if (inclass) {
if (c == ']')
inclass = 0;
strbuf_putc(sb, c);
} else if (c == '\\') {
quote = 1;
strbuf_putc(sb, c);
} else if (c == '[') {
inclass = 1;
strbuf_putc(sb, c);
if (pattern[i + 1] == ']')
strbuf_putc(sb, pattern[++i]);
} else if (c == '.') {
strbuf_puts(sb, TOKEN_CHARS);
} else if (c == '$' && i == len - 1) {
dollar = 1;
} else {
strbuf_putc(sb, c);
}
}
if (!dollar) {
strbuf_puts(sb, TOKEN_CHARS);
strbuf_putc(sb, '*');
}
} else {
strbuf_puts(sb, pattern);
}
strbuf_puts(sb, "\\b");
locked = 1;
} else if (flags & CONVERT_PATH) {
if (*pattern == '^') {
strbuf_putc(sb, *pattern++);
if (*pattern != '/')
strbuf_putc(sb, '/');
}
strbuf_puts(sb, pattern);
locked = 1;
} else if (flags & CONVERT_GREP || isregex(pattern)) {
strbuf_puts(sb, pattern);
locked = 1;
} else {
strbuf_puts(sb, "\\b");
strbuf_puts(sb, pattern);
strbuf_puts(sb, "\\b");
}
if (debug)
fprintf(stdout, "regex: |%s|\n", strbuf_value(sb));
if (!(flags & CONVERT_BASIC))
rewrite_flags |= REG_EXTENDED;
if (flags & CONVERT_ICASE)
rewrite_flags |= REG_ICASE;
/* compile the regular expression */
if (rewrite_pattern(rewrite, strbuf_value(sb), rewrite_flags) < 0)
die("invalid regular expression. '%s'", strbuf_value(sb));
}
/**
* void set_print0(void)
*
* set_print0: change newline to '\0'.
*/
static int newline = '\n';
void
set_print0(void)
{
newline = '\0';
}
/**
* Path filter for the output of global(1).
* The path name starts with "./" which is the project root directory.
*/
static const char *
convert_pathname(CONVERT *cv, const char *path)
{
static char buf[MAXPATHLEN];
const char *a, *b;
if (flags & CONVERT_COLOR && flags & CONVERT_PATH) {
STATIC_STRBUF(sb);
const char *p;
/* color the path */
path = rewrite_string(rewrite, path + 1, 0);
/* normalize the path */
strbuf_clear(sb);
strbuf_puts(sb, "./");
for (p = path; *p && (*p == '/' || *p == ESC); p++) {
if (*p == ESC) {
for (; *p && *p != EOE; p++)
strbuf_putc(sb, *p);
strbuf_putc(sb, *p);
}
}
strbuf_puts(sb, p);
path = strbuf_value(sb);
}
if (cv->type != PATH_THROUGH) {
/*
* make absolute path name.
* 'path + 1' means skipping "." at the head.
*/
strbuf_setlen(cv->abspath, cv->start_point);
strbuf_puts(cv->abspath, path + 1);
/*
* print path name with converting.
*/
switch (cv->type) {
case PATH_ABSOLUTE:
path = strbuf_value(cv->abspath);
break;
case PATH_RELATIVE:
case PATH_SHORTER:
a = strbuf_value(cv->abspath);
b = cv->basedir;
#if defined(_WIN32) || defined(__DJGPP__)
/*
* use absolute if on different drives.
*/
if (tolower(*a) != tolower(*b)) {
path = a;
break;
}
while (*a != '/')
a++;
while (*b != '/')
b++;
#endif
if (!abs2rel(a, b, buf, sizeof(buf)))
die("abs2rel failed. (path=%s, base=%s).", a, b);
path = buf;
if (cv->type == PATH_SHORTER && strlen(path) > strbuf_getlen(cv->abspath))
path = strbuf_value(cv->abspath);
break;
default:
die("unknown path type.");
break;
}
}
/*
* encoding of the path name.
*/
if (use_encoding()) {
const char *p;
int required = 0;
for (p = path; *p; p++) {
if (required_encode(*p)) {
required = 1;
break;
}
}
if (required) {
static char buf[MAXPATHLEN];
char c[16] = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'};
char *q = buf;
for (p = path; *p; p++) {
if (required_encode(*p)) {
*q++ = '%';
*q++ = c[*p / 16];
*q++ = c[*p % 16];
} else
*q++ = *p;
}
*q = '\0';
path = buf;
}
}
return (const char *)path;
}
/**
* convert_open: open convert filter
*
* @param[in] type PATH_ABSOLUTE, PATH_RELATIVE, PATH_THROUGH
* @param[in] format tag record format
* @param[in] root root directory of source tree
* @param[in] cwd current directory
* @param[in] dbpath dbpath directory
* @param[in] op output file
* @param[in] db tag type (GTAGS, GRTAGS, GSYMS, GPATH, NOTAGS)
*/
CONVERT *
convert_open(int type, int format, const char *root, const char *cwd, const char *dbpath, FILE *op, int db)
{
CONVERT *cv = (CONVERT *)check_calloc(sizeof(CONVERT), 1);
/*
* set base directory.
*/
cv->abspath = strbuf_open(MAXPATHLEN);
strbuf_puts(cv->abspath, root);
strbuf_unputc(cv->abspath, '/');
cv->start_point = strbuf_getlen(cv->abspath);
/*
* copy elements.
*/
if (strlen(cwd) > MAXPATHLEN)
die("current directory name too long.");
strlimcpy(cv->basedir, cwd, sizeof(cv->basedir));
cv->type = type;
cv->format = format;
cv->op = op;
cv->db = db;
/*
* open GPATH.
*/
if (gpath_open(dbpath, 0) < 0)
die("GPATH not found.");
/*
* setup coloring.
*/
code_fputs = fputs;
if (flags & CONVERT_COLOR) {
set_color_method();
if (!(flags & CONVERT_PATH))
code_fputs = color_code_fputs;
}
return cv;
}
/**
* convert_put: convert path into relative or absolute and print.
*
* @param[in] cv CONVERT structure
* @param[in] ctags_x tag record (ctags-x format)
*
* [Note] This function is only called by global with the --path option.
*/
void
convert_put(CONVERT *cv, const char *ctags_x)
{
char *tagnextp = NULL;
int tagnextc = 0;
char *tag = NULL, *lineno = NULL, *path, *rest = NULL;
const char *fid = NULL;
if (cv->format == FORMAT_PATH)
die("convert_put: internal error."); /* Use convert_put_path() */
/*
* parse tag line.
* Don't use split() function not to destroy line image.
*/
{
char *p = (char *)ctags_x;
/*
* tag name
*/
tag = p;
for (; *p && !isspace(*p); p++)
;
if (*p == '\0')
die("invalid ctags-x format (line number not found).");
tagnextp = p;
tagnextc = *p;
*p++ = '\0';
/* skip blanks */
for (; *p && isspace(*p); p++)
;
if (*p == '\0')
die("invalid ctags-x format (line number not found).");
/*
* line number
*/
lineno = p;
for (; *p && !isspace(*p); p++)
;
if (*p == '\0')
die("invalid ctags-x format (path name not found).");
*p++ = '\0';
/* skip blanks */
for (; *p && isspace(*p); p++)
;
if (*p == '\0')
die("invalid ctags-x format (path name not found).");
/*
* path name
*/
path = p;
for (; *p && !isspace(*p); p++)
;
if (*p == '\0')
die("invalid ctags-x format (line image not found).");
*p++ = '\0';
rest = p;
}
/*
* The path name has already been encoded.
*/
path = decode_path(path);
switch (cv->format) {
case FORMAT_CTAGS:
case FORMAT_CTAGS_PLUS:
fputs(tag, cv->op);
fputc('\t', cv->op);
fputs(convert_pathname(cv, path), cv->op);
fputc('\t', cv->op);
fputs(lineno, cv->op);
if (cv->format == FORMAT_CTAGS_PLUS) {
fputc('\t', cv->op);
fputs(rest, cv->op);
}
break;
case FORMAT_CTAGS_XID:
fid = gpath_path2fid(path, NULL);
if (fid == NULL)
die("convert_put: unknown file. '%s'", path);
fputs(fid, cv->op);
fputc(' ', cv->op);
/* PASS THROUGH */
case FORMAT_CTAGS_X:
/*
* print until path name.
*/
*tagnextp = tagnextc;
fputs(ctags_x, cv->op);
fputc(' ', cv->op);
/*
* print path name and the rest.
*/
fputs(convert_pathname(cv, path), cv->op);
fputc(' ', cv->op);
fputs(rest, cv->op);
break;
case FORMAT_CTAGS_MOD:
fputs(convert_pathname(cv, path), cv->op);
fputc('\t', cv->op);
fputs(lineno, cv->op);
fputc('\t', cv->op);
fputs(rest, cv->op);
break;
case FORMAT_GREP:
fputs(convert_pathname(cv, path), cv->op);
fputc(':', cv->op);
fputs(lineno, cv->op);
fputc(':', cv->op);
fputs(rest, cv->op);
break;
case FORMAT_CSCOPE:
fputs(convert_pathname(cv, path), cv->op);
fputc(' ', cv->op);
fputs(tag, cv->op);
fputc(' ', cv->op);
fputs(lineno, cv->op);
fputc(' ', cv->op);
for (; *rest && isspace(*rest); rest++)
;
if (*rest)
fputs(rest, cv->op);
else
fputs("", cv->op);
break;
default:
die("unknown format type.");
}
(void)fputc(newline, cv->op);
}
/**
* convert_put_path: convert path into relative or absolute and print.
*
* @param[in] cv CONVERT structure
* @param[in] pattern pattern
* @param[in] path path name
*/
void
convert_put_path(CONVERT *cv, const char *pattern, const char *path)
{
if (flags & CONVERT_COLOR && !locked && pattern)
set_color_tag(pattern);
if (cv->format != FORMAT_PATH)
die("convert_put_path: internal error.");
fputs(convert_pathname(cv, path), cv->op);
(void)fputc(newline, cv->op);
}
/**
* convert_put_using: convert path into relative or absolute and print.
*
* @param[in] cv CONVERT structure
* @param[in] tag tag name
* @param[in] path path name
* @param[in] lineno line number
* @param[in] rest line image
* @param[in] fid file id (only when fid != NULL)
*/
void
convert_put_using(CONVERT *cv, const char *tag, const char *path, int lineno, const char *rest, const char *fid)
{
if (rest == NULL)
rest = ""; /* for safety */
if (flags & CONVERT_COLOR && !locked)
set_color_tag(tag);
if (cv->tag_for_display)
tag = cv->tag_for_display;
switch (cv->format) {
case FORMAT_PATH:
fputs(convert_pathname(cv, path), cv->op);
break;
case FORMAT_CTAGS:
case FORMAT_CTAGS_PLUS:
fputs(tag, cv->op);
fputc('\t', cv->op);
fputs(convert_pathname(cv, path), cv->op);
fputc('\t', cv->op);
fprintf(cv->op, "%d", lineno);
if (cv->format == FORMAT_CTAGS_PLUS) {
fputc('\t', cv->op);
code_fputs(rest, cv->op);
}
break;
case FORMAT_CTAGS_XID:
if (fid == NULL) {
fid = gpath_path2fid(path, NULL);
if (fid == NULL)
die("convert_put_using: unknown file. '%s'", path);
}
fputs(fid, cv->op);
fputc(' ', cv->op);
/* PASS THROUGH */
case FORMAT_CTAGS_X:
fprintf(cv->op, "%-16s %4d %-16s ",
tag, lineno, convert_pathname(cv, path));
code_fputs(rest, cv->op);
break;
case FORMAT_CTAGS_MOD:
fputs(convert_pathname(cv, path), cv->op);
fputc('\t', cv->op);
fprintf(cv->op, "%d", lineno);
fputc('\t', cv->op);
code_fputs(rest, cv->op);
break;
case FORMAT_GREP:
fputs(convert_pathname(cv, path), cv->op);
fputc(':', cv->op);
fprintf(cv->op, "%d", lineno);
fputc(':', cv->op);
code_fputs(rest, cv->op);
break;
case FORMAT_CSCOPE:
fputs(convert_pathname(cv, path), cv->op);
fputc(' ', cv->op);
fputs(tag, cv->op);
fputc(' ', cv->op);
fprintf(cv->op, "%d", lineno);
fputc(' ', cv->op);
for (; *rest && isspace(*rest); rest++)
;
if (*rest)
code_fputs(rest, cv->op);
else
fputs("", cv->op);
break;
default:
die("unknown format type.");
}
(void)fputc(newline, cv->op);
}
void
convert_close(CONVERT *cv)
{
strbuf_close(cv->abspath);
gpath_close();
free(cv);
}