/* * Copyright (c) 2010 * Tama Communications Corporation * Copyright (c) 2014 * Yoshitaro Makise * * 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 __MINGW32__ #define __USE_MINGW_ANSI_STDIO 0 /* no need for C99 sprintf here */ #endif #ifdef HAVE_CONFIG_H #include #endif #include #include #include #include #include #ifdef STDC_HEADERS #include #endif #ifdef HAVE_STRING_H #include #else #include #endif #ifdef HAVE_UNISTD_H #include #endif #include "parser.h" #if defined(_WIN32) && !defined(__CYGWIN__) #define PYTHON "python" #define PYGMENTS_PARSER "../share/gtags/script/pygments_parser.py" #else #define PYGMENTS_PARSER (DATADIR "/gtags/script/pygments_parser.py") #endif /* * Function layer plugin parser sample */ #define TERMINATOR "###terminator###" #define LANGMAP_OPTION "--langmap=" #define INITIAL_BUFSIZE 1024 static FILE *ip, *op; static char *linebuf; static size_t bufsize; #ifdef __GNUC__ static void terminate_process(void) __attribute__((destructor)); #endif static void copy_langmap_converting_cpp(char *dst, const char *src) { const char *p; if (strncmp(src, "cpp:", 4) == 0) { memcpy(dst, "c++:", 4); dst += 4; src += 4; } while ((p = strstr(src, ",cpp:")) != NULL) { memcpy(dst, src, p - src); dst += p - src; memcpy(dst, ",c++:", 5); dst += 5; src = p + 5; } strcpy(dst, src); } #if defined(_WIN32) && !defined(__CYGWIN__) #define WIN32_LEAN_AND_MEAN #include #include static HANDLE pid; static void start_process(const struct parser_param *param) { HANDLE opipe[2], ipipe[2]; SECURITY_ATTRIBUTES sa; STARTUPINFO si; PROCESS_INFORMATION pi; char* arg; char parser[MAX_PATH*2]; size_t len; GetModuleFileName(NULL, parser, MAX_PATH); arg = strrchr(parser, '\\'); strcpy(arg+1, PYGMENTS_PARSER); arg = malloc(sizeof(PYTHON) + strlen(parser) + sizeof(LANGMAP_OPTION) + strlen(param->langmap) + 2 + 1); if (arg == NULL) param->die("short of memory."); len = sprintf(arg, "%s \"%s\" %s", PYTHON, parser, LANGMAP_OPTION); copy_langmap_converting_cpp(arg + len, param->langmap); sa.nLength = sizeof(sa); sa.bInheritHandle = TRUE; sa.lpSecurityDescriptor = NULL; if (!CreatePipe(&opipe[0], &opipe[1], &sa, 0) || !CreatePipe(&ipipe[0], &ipipe[1], &sa, 0)) param->die("CreatePipe failed."); SetHandleInformation(opipe[1], HANDLE_FLAG_INHERIT, 0); SetHandleInformation(ipipe[0], HANDLE_FLAG_INHERIT, 0); ZeroMemory(&si, sizeof(si)); si.cb = sizeof(si); si.hStdInput = opipe[0]; si.hStdOutput = ipipe[1]; si.hStdError = GetStdHandle(STD_ERROR_HANDLE); si.dwFlags = STARTF_USESTDHANDLES; if (!CreateProcess(NULL, arg, NULL, NULL, TRUE, 0, NULL, NULL, &si, &pi)) param->die("no python"); CloseHandle(opipe[0]); CloseHandle(ipipe[1]); CloseHandle(pi.hThread); pid = pi.hProcess; op = fdopen(_open_osfhandle((intptr_t)opipe[1], _O_WRONLY), "w"); ip = fdopen(_open_osfhandle((intptr_t)ipipe[0], _O_RDONLY), "r"); if (ip == NULL || op == NULL) param->die("fdopen failed."); bufsize = INITIAL_BUFSIZE; linebuf = malloc(bufsize); if (linebuf == NULL) param->die("short of memory."); } static void terminate_process(void) { if (op == NULL) return; free(linebuf); fclose(op); fclose(ip); WaitForSingleObject(pid, INFINITE); CloseHandle(pid); } #else #include static char *argv[] = { PYGMENTS_PARSER, NULL, NULL }; static pid_t pid; static void start_process(const struct parser_param *param) { int opipe[2], ipipe[2]; argv[1] = malloc(sizeof(LANGMAP_OPTION) + strlen(param->langmap)); if (argv[1] == NULL) param->die("short of memory."); memcpy(argv[1], LANGMAP_OPTION, sizeof(LANGMAP_OPTION) - 1); copy_langmap_converting_cpp(argv[1] + sizeof(LANGMAP_OPTION) - 1, param->langmap); if (pipe(opipe) < 0 || pipe(ipipe) < 0) param->die("cannot create pipe."); pid = fork(); if (pid == 0) { /* child process */ close(opipe[1]); close(ipipe[0]); if (dup2(opipe[0], STDIN_FILENO) < 0 || dup2(ipipe[1], STDOUT_FILENO) < 0) param->die("dup2 failed."); close(opipe[0]); close(ipipe[1]); execvp(PYGMENTS_PARSER, argv); param->die("cannot execute '%s'. (execvp failed)", PYGMENTS_PARSER); } /* parent process */ if (pid < 0) param->die("fork failed."); free(argv[1]); close(opipe[0]); close(ipipe[1]); ip = fdopen(ipipe[0], "r"); op = fdopen(opipe[1], "w"); if (ip == NULL || op == NULL) param->die("fdopen failed."); bufsize = INITIAL_BUFSIZE; linebuf = malloc(bufsize); if (linebuf == NULL) param->die("short of memory."); } static void terminate_process(void) { if (op == NULL) return; free(linebuf); fclose(op); fclose(ip); while (waitpid(pid, NULL, 0) < 0 && errno == EINTR) ; } #endif static char * get_line(const struct parser_param *param) { size_t linelen = 0; for (;;) { if (fgets(linebuf + linelen, bufsize - linelen, ip) == NULL) { if (linelen == 0) return NULL; break; } linelen += strlen(linebuf + linelen); if (linelen < bufsize - 1 || linebuf[linelen - 1] == '\n' || feof(ip)) break; bufsize *= 2; linebuf = realloc(linebuf, bufsize); if (linebuf == NULL) param->die("short of memory."); } while (linelen-- > 0 && (linebuf[linelen] == '\n' || linebuf[linelen] == '\r')) linebuf[linelen] = '\0'; return linebuf; } static void put_line(char *line, const struct parser_param *param) { int lineno; int type = PARSER_DEF; char *p, *tagname, *filename; /* * Output of ctags: * ctags -x ... * main 326 global/global.c main(int argc, char **argv) * * ctags -x --gtags ... * D main 326 global/global.c main(int argc, char **argv) */ switch (*line) { case 'D': type = PARSER_DEF; break; case 'R': type = PARSER_REF_SYM; break; default: param->die("unexpected type string: %s", line); } /* skip type string */ while (*line && !isspace((unsigned char)*line)) line++; while (*line && isspace((unsigned char)*line)) line++; filename = strstr(line, param->file); if (filename == NULL || filename == line) return; p = filename - 1; if (!isspace((unsigned char)*p)) return; while (p >= line && isspace((unsigned char)*p)) *p-- = '\0'; if (p < line) return; if (!isdigit((unsigned char)*p)) return; while (p >= line && isdigit((unsigned char)*p)) p--; if (p < line) return; lineno = atoi(p + 1); if (!isspace((unsigned char)*p)) return; while (p >= line && isspace((unsigned char)*p)) *p-- = '\0'; if (p < line) return; while (p >= line && !isspace((unsigned char)*p)) p--; tagname = p + 1; p = filename + strlen(param->file); if (*p != '\0') { if (!isspace((unsigned char)*p)) return; *p++ = '\0'; while (isspace((unsigned char)*p)) p++; } param->put(type, tagname, lineno, filename, p, param->arg); } void parser(const struct parser_param *param) { char *line; assert(param->size >= sizeof(*param)); if (op == NULL) start_process(param); /* Write path of input file to pipe. */ fputs(param->file, op); putc('\n', op); fflush(op); /* Read output of the process. */ for (;;) { line = get_line(param); if (line == NULL) param->die("unexpected EOF."); if (strcmp(line, TERMINATOR) == 0) break; put_line(line, param); } }