?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
db: use the load_strings_from_file() helper function
[smatch.git] / semind.c
blob911fc7470a30c53cb45553e830e41426ff39118c
1 /*
2 * semind - semantic indexer for C.
3 *
4 * Copyright (C) 2020 Alexey Gladkov
5 */
6
7 #define _GNU_SOURCE
8 #include <sys/types.h>
9 #include <sys/stat.h>
10
11 #include <unistd.h>
12 #include <limits.h>
13 #include <stdlib.h>
14 #include <string.h>
15 #include <fcntl.h>
16 #include <getopt.h>
17 #include <ctype.h>
18 #include <errno.h>
19 #include <sqlite3.h>
20
21 #include "dissect.h"
22
23 #define U_DEF (0x100 << U_SHIFT)
24 #define SINDEX_DATABASE_VERSION 1
25
26 #define message(fmt, ...) semind_error(0, 0, (fmt), ##__VA_ARGS__)
27
28 static const char *progname;
29 static const char *semind_command = NULL;
30
31 // common options
32 static const char *semind_dbfile = "semind.sqlite";
33 static int semind_verbose = 0;
34 static char cwd[PATH_MAX];
35 static size_t n_cwd;
36
37 // 'add' command options
38 static struct string_list *semind_filelist = NULL;
39 static int semind_include_local_syms = 0;
40
41 struct semind_streams {
42 sqlite3_int64 id;
43 };
44
45 static struct semind_streams *semind_streams = NULL;
46 static int semind_streams_nr = 0;
47
48 // 'search' command options
49 static int semind_search_modmask;
50 static int semind_search_modmask_defined = 0;
51 static int semind_search_kind = 0;
52 static char *semind_search_path = NULL;
53 static char *semind_search_symbol = NULL;
54 static const char *semind_search_format = "(%m) %f\t%l\t%c\t%C\t%s";
55
56 #define EXPLAIN_LOCATION 1
57 #define USAGE_BY_LOCATION 2
58 static int semind_search_by_location;
59 static char *semind_search_filename;
60 static int semind_search_line;
61 static int semind_search_column;
62
63 static sqlite3 *semind_db = NULL;
64 static sqlite3_stmt *lock_stmt = NULL;
65 static sqlite3_stmt *unlock_stmt = NULL;
66 static sqlite3_stmt *insert_rec_stmt = NULL;
67 static sqlite3_stmt *select_file_stmt = NULL;
68 static sqlite3_stmt *insert_file_stmt = NULL;
69 static sqlite3_stmt *delete_file_stmt = NULL;
70
71 struct command {
72 const char *name;
73 int dbflags;
74 void (*parse_cmdline)(int argc, char **argv);
75 void (*handler)(int argc, char **argv);
76 };
77
78 static void show_usage(void)
79 {
80 if (semind_command)
81 printf("Try '%s %s --help' for more information.\n",
82 progname, semind_command);
83 else
84 printf("Try '%s --help' for more information.\n",
85 progname);
86 exit(1);
87 }
88
89 static void show_help(int ret)
90 {
91 printf(
92 "Usage: %1$s [options]\n"
93 " or: %1$s [options] add [command options] [--] [compiler options] [files...]\n"
94 " or: %1$s [options] rm [command options] pattern\n"
95 " or: %1$s [options] search [command options] pattern\n"
96 "\n"
97 "These are common %1$s commands used in various situations:\n"
98 " add Generate or updates semantic index file for c-source code;\n"
99 " rm Remove files from the index by pattern;\n"
100 " search Make index queries.\n"
101 "\n"
102 "Options:\n"
103 " -D, --database=FILE Specify database file (default: %2$s);\n"
104 " -B, --basedir=DIR Define project top directory (default is the current directory);\n"
105 " -v, --verbose Show information about what is being done;\n"
106 " -h, --help Show this text and exit.\n"
107 "\n"
108 "Environment:\n"
109 " SINDEX_DATABASE Database file location.\n"
110 " SINDEX_BASEDIR Project top directory.\n"
111 "\n"
112 "Report bugs to authors.\n"
113 "\n",
114 progname, semind_dbfile);
115 exit(ret);
116 }
117
118 static void show_help_add(int ret)
119 {
120 printf(
121 "Usage: %1$s add [options] [--] [compiler options] files...\n"
122 "\n"
123 "Utility creates or updates a symbol index.\n"
124 "\n"
125 "Options:\n"
126 " --include-local-syms Include into the index local symbols;\n"
127 " -v, --verbose Show information about what is being done;\n"
128 " -h, --help Show this text and exit.\n"
129 "\n"
130 "Report bugs to authors.\n"
131 "\n",
132 progname);
133 exit(ret);
134
135 }
136
137 static void show_help_rm(int ret)
138 {
139 printf(
140 "Usage: %1$s rm [options] pattern\n"
141 "\n"
142 "Utility removes source files from the index.\n"
143 "The pattern is a glob(7) wildcard pattern.\n"
144 "\n"
145 "Options:\n"
146 " -v, --verbose Show information about what is being done;\n"
147 " -h, --help Show this text and exit.\n"
148 "\n"
149 "Report bugs to authors.\n"
150 "\n",
151 progname);
152 exit(ret);
153 }
154
155 static void show_help_search(int ret)
156 {
157 printf(
158 "Usage: %1$s search [options] [pattern]\n"
159 " or: %1$s search [options] (-e|-l) filename[:linenr[:column]]\n"
160 "\n"
161 "Utility searches information about symbol by pattern.\n"
162 "The pattern is a glob(7) wildcard pattern.\n"
163 "\n"
164 "Options:\n"
165 " -f, --format=STRING Specify an output format;\n"
166 " -p, --path=PATTERN Search symbols only in specified directories;\n"
167 " -m, --mode=MODE Search only the specified type of access;\n"
168 " -k, --kind=KIND Specify a kind of symbol;\n"
169 " -e, --explain Show what happens in the specified file position;\n"
170 " -l, --location Show usage of symbols from a specific file position;\n"
171 " -v, --verbose Show information about what is being done;\n"
172 " -h, --help Show this text and exit.\n"
173 "\n"
174 "The KIND can be one of the following: `s', `f', `v', `m'.\n"
175 "\n"
176 "Report bugs to authors.\n"
177 "\n",
178 progname);
179 exit(ret);
180 }
181
182 static void semind_print_progname(void)
183 {
184 fprintf(stderr, "%s: ", progname);
185 if (semind_command)
186 fprintf(stderr, "%s: ", semind_command);
187 }
188
189 static void semind_error(int status, int errnum, const char *fmt, ...)
190 {
191 va_list ap;
192 semind_print_progname();
193
194 va_start(ap, fmt);
195 vfprintf(stderr, fmt, ap);
196 va_end(ap);
197
198 if (errnum > 0)
199 fprintf(stderr, ": %s", strerror(errnum));
200
201 fprintf(stderr, "\n");
202
203 if (status)
204 exit(status);
205 }
206
207 static void set_search_modmask(const char *v)
208 {
209 size_t n = strlen(v);
210
211 if (n != 1 && n != 3)
212 semind_error(1, 0, "the length of mode value must be 1 or 3: %s", v);
213
214 semind_search_modmask_defined = 1;
215 semind_search_modmask = 0;
216
217 if (n == 1) {
218 switch (v[0]) {
219 case 'r': v = "rrr"; break;
220 case 'w': v = "ww-"; break;
221 case 'm': v = "mmm"; break;
222 case '-': v = "---"; break;
223 default: semind_error(1, 0, "unknown modificator: %s", v);
224 }
225 } else if (!strcmp(v, "def")) {
226 semind_search_modmask = U_DEF;
227 return;
228 }
229
230 static const int modes[] = {
231 U_R_AOF, U_W_AOF, U_R_AOF | U_W_AOF,
232 U_R_VAL, U_W_VAL, U_R_VAL | U_W_VAL,
233 U_R_PTR, U_W_PTR, U_R_PTR | U_W_PTR,
234 };
235
236 for (int i = 0; i < 3; i++) {
237 switch (v[i]) {
238 case 'r': semind_search_modmask |= modes[i * 3]; break;
239 case 'w': semind_search_modmask |= modes[i * 3 + 1]; break;
240 case 'm': semind_search_modmask |= modes[i * 3 + 2]; break;
241 case '-': break;
242 default: semind_error(1, 0,
243 "unknown modificator in the mode value"
244 " (`r', `w', `m' or `-' expected): %c", v[i]);
245 }
246 }
247 }
248
249 static void parse_cmdline(int argc, char **argv)
250 {
251 static const struct option long_options[] = {
252 { "database", required_argument, NULL, 'D' },
253 { "basedir", required_argument, NULL, 'B' },
254 { "verbose", no_argument, NULL, 'v' },
255 { "help", no_argument, NULL, 'h' },
256 { NULL }
257 };
258 int c;
259 char *basedir = getenv("SINDEX_BASEDIR");
260 char *env;
261
262 if ((env = getenv("SINDEX_DATABASE")) != NULL)
263 semind_dbfile = env;
264
265 while ((c = getopt_long(argc, argv, "+B:D:vh", long_options, NULL)) != -1) {
266 switch (c) {
267 case 'D':
268 semind_dbfile = optarg;
269 break;
270 case 'B':
271 basedir = optarg;
272 break;
273 case 'v':
274 semind_verbose++;
275 break;
276 case 'h':
277 show_help(0);
278 }
279 }
280
281 if (optind == argc) {
282 message("command required");
283 show_usage();
284 }
285
286 if (basedir) {
287 if (!realpath(basedir, cwd))
288 semind_error(1, errno, "unable to get project base directory");
289 n_cwd = strlen(cwd);
290 }
291 }
292
293 static void parse_cmdline_add(int argc, char **argv)
294 {
295 static const struct option long_options[] = {
296 { "include-local-syms", no_argument, NULL, 1 },
297 { "verbose", no_argument, NULL, 'v' },
298 { "help", no_argument, NULL, 'h' },
299 { NULL }
300 };
301 int c;
302
303 opterr = 0;
304
305 while ((c = getopt_long(argc, argv, "+vh", long_options, NULL)) != -1) {
306 switch (c) {
307 case 1:
308 semind_include_local_syms = 1;
309 break;
310 case 'v':
311 semind_verbose++;
312 break;
313 case 'h':
314 show_help_add(0);
315 case '?':
316 goto done;
317 }
318 }
319 done:
320 if (optind == argc) {
321 message("more arguments required");
322 show_usage();
323 }
324
325 // enforce tabstop
326 tabstop = 1;
327
328 // step back since sparse_initialize will ignore argv[0].
329 optind--;
330
331 sparse_initialize(argc - optind, argv + optind, &semind_filelist);
332 }
333
334 static void parse_cmdline_rm(int argc, char **argv)
335 {
336 static const struct option long_options[] = {
337 { "verbose", no_argument, NULL, 'v' },
338 { "help", no_argument, NULL, 'h' },
339 { NULL }
340 };
341 int c;
342
343 while ((c = getopt_long(argc, argv, "+vh", long_options, NULL)) != -1) {
344 switch (c) {
345 case 'v':
346 semind_verbose++;
347 break;
348 case 'h':
349 show_help_rm(0);
350 }
351 }
352
353 if (optind == argc) {
354 message("more arguments required");
355 show_usage();
356 }
357 }
358
359 static void parse_cmdline_search(int argc, char **argv)
360 {
361 static const struct option long_options[] = {
362 { "explain", no_argument, NULL, 'e' },
363 { "format", required_argument, NULL, 'f' },
364 { "path", required_argument, NULL, 'p' },
365 { "location", no_argument, NULL, 'l' },
366 { "mode", required_argument, NULL, 'm' },
367 { "kind", required_argument, NULL, 'k' },
368 { "verbose", no_argument, NULL, 'v' },
369 { "help", no_argument, NULL, 'h' },
370 { NULL }
371 };
372 int c;
373
374 while ((c = getopt_long(argc, argv, "+ef:m:k:p:lvh", long_options, NULL)) != -1) {
375 switch (c) {
376 case 'e':
377 semind_search_by_location = EXPLAIN_LOCATION;
378 break;
379 case 'l':
380 semind_search_by_location = USAGE_BY_LOCATION;
381 break;
382 case 'f':
383 semind_search_format = optarg;
384 break;
385 case 'm':
386 set_search_modmask(optarg);
387 break;
388 case 'k':
389 semind_search_kind = tolower(optarg[0]);
390 break;
391 case 'p':
392 semind_search_path = optarg;
393 break;
394 case 'v':
395 semind_verbose++;
396 break;
397 case 'h':
398 show_help_search(0);
399 }
400 }
401
402 if (semind_search_by_location) {
403 char *str;
404
405 if (optind == argc)
406 semind_error(1, 0, "one argument required");
407
408 str = argv[optind];
409
410 while (str) {
411 char *ptr;
412
413 if ((ptr = strchr(str, ':')) != NULL)
414 *ptr++ = '\0';
415
416 if (*str != '\0') {
417 if (!semind_search_filename) {
418 semind_search_filename = str;
419 } else if (!semind_search_line) {
420 semind_search_line = atoi(str);
421 } else if (!semind_search_column) {
422 semind_search_column = atoi(str);
423 }
424 }
425 str = ptr;
426 }
427 } else if (optind < argc)
428 semind_search_symbol = argv[optind++];
429 }
430
431 static int query_appendf(sqlite3_str *query, const char *fmt, ...)
432 {
433 int status;
434 va_list args;
435
436 va_start(args, fmt);
437 sqlite3_str_vappendf(query, fmt, args);
438 va_end(args);
439
440 if ((status = sqlite3_str_errcode(query)) == SQLITE_OK)
441 return 0;
442
443 if (status == SQLITE_NOMEM)
444 message("not enough memory");
445
446 if (status == SQLITE_TOOBIG)
447 message("string too big");
448
449 return -1;
450 }
451
452 static inline void sqlite_bind_text(sqlite3_stmt *stmt, const char *field, const char *var, int len)
453 {
454 if (sqlite3_bind_text(stmt, sqlite3_bind_parameter_index(stmt, field), var, len, SQLITE_STATIC) != SQLITE_OK)
455 semind_error(1, 0, "unable to bind value for %s: %s", field, sqlite3_errmsg(semind_db));
456 }
457
458 static inline void sqlite_bind_int64(sqlite3_stmt *stmt, const char *field, long long var)
459 {
460 if (sqlite3_bind_int64(stmt, sqlite3_bind_parameter_index(stmt, field), var) != SQLITE_OK)
461 semind_error(1, 0, "unable to bind value for %s: %s", field, sqlite3_errmsg(semind_db));
462 }
463
464 static inline void sqlite_prepare(const char *sql, sqlite3_stmt **stmt)
465 {
466 int ret;
467 do {
468 ret = sqlite3_prepare_v2(semind_db, sql, -1, stmt, NULL);
469 if (ret != SQLITE_OK && ret != SQLITE_BUSY)
470 semind_error(1, 0, "unable to prepare query: %s: %s", sqlite3_errmsg(semind_db), sql);
471 } while (ret == SQLITE_BUSY);
472 }
473
474 static inline void sqlite_prepare_persistent(const char *sql, sqlite3_stmt **stmt)
475 {
476 int ret;
477 do {
478 ret = sqlite3_prepare_v3(semind_db, sql, -1, SQLITE_PREPARE_PERSISTENT, stmt, NULL);
479 if (ret != SQLITE_OK && ret != SQLITE_BUSY)
480 semind_error(1, 0, "unable to prepare query: %s: %s", sqlite3_errmsg(semind_db), sql);
481 } while (ret == SQLITE_BUSY);
482 }
483
484 static inline void sqlite_reset_stmt(sqlite3_stmt *stmt)
485 {
486 // Contrary to the intuition of many, sqlite3_reset() does not reset the
487 // bindings on a prepared statement. Use this routine to reset all host
488 // parameters to NULL.
489 sqlite3_clear_bindings(stmt);
490 sqlite3_reset(stmt);
491 }
492
493 static int sqlite_run(sqlite3_stmt *stmt)
494 {
495 int ret = sqlite3_step(stmt);
496 if (ret != SQLITE_DONE && ret != SQLITE_ROW)
497 semind_error(1, 0, "unable to process query: %s: %s", sqlite3_errmsg(semind_db), sqlite3_sql(stmt));
498 return ret;
499 }
500
501 static void sqlite_command(const char *sql)
502 {
503 sqlite3_stmt *stmt;
504 sqlite_prepare(sql, &stmt);
505 sqlite_run(stmt);
506 sqlite3_finalize(stmt);
507 }
508
509 static sqlite3_int64 get_db_version(void)
510 {
511 sqlite3_stmt *stmt;
512 sqlite3_int64 dbversion;
513
514 sqlite_prepare("PRAGMA user_version", &stmt);
515 sqlite_run(stmt);
516 dbversion = sqlite3_column_int64(stmt, 0);
517 sqlite3_finalize(stmt);
518
519 return dbversion;
520 }
521
522 static void set_db_version(void)
523 {
524 char *sql;
525 sqlite3_str *query = sqlite3_str_new(semind_db);
526
527 if (query_appendf(query, "PRAGMA user_version = %d", SINDEX_DATABASE_VERSION) < 0)
528 exit(1);
529
530 sql = sqlite3_str_finish(query);
531 sqlite_command(sql);
532 sqlite3_free(sql);
533 }
534
535 static void open_temp_database(void)
536 {
537 static const char *database_schema[] = {
538 "ATTACH ':memory:' AS tempdb",
539 "CREATE TABLE tempdb.semind ("
540 " file INTEGER NOT NULL,"
541 " line INTEGER NOT NULL,"
542 " column INTEGER NOT NULL,"
543 " symbol TEXT NOT NULL,"
544 " kind INTEGER NOT NULL,"
545 " context TEXT,"
546 " mode INTEGER NOT NULL"
547 ")",
548 NULL,
549 };
550
551 for (int i = 0; database_schema[i]; i++)
552 sqlite_command(database_schema[i]);
553 }
554
555 static void open_database(const char *filename, int flags)
556 {
557 static const char *database_schema[] = {
558 "CREATE TABLE file ("
559 " id INTEGER PRIMARY KEY AUTOINCREMENT,"
560 " name TEXT UNIQUE NOT NULL,"
561 " mtime INTEGER NOT NULL"
562 ")",
563 "CREATE TABLE semind ("
564 " file INTEGER NOT NULL REFERENCES file(id) ON DELETE CASCADE,"
565 " line INTEGER NOT NULL,"
566 " column INTEGER NOT NULL,"
567 " symbol TEXT NOT NULL,"
568 " kind INTEGER NOT NULL,"
569 " context TEXT,"
570 " mode INTEGER NOT NULL"
571 ")",
572 "CREATE UNIQUE INDEX semind_0 ON semind (symbol, kind, mode, file, line, column)",
573 "CREATE INDEX semind_1 ON semind (file)",
574 NULL,
575 };
576
577 int exists = !access(filename, R_OK);
578
579 if (sqlite3_open_v2(filename, &semind_db, flags, NULL) != SQLITE_OK)
580 semind_error(1, 0, "unable to open database: %s: %s", filename, sqlite3_errmsg(semind_db));
581
582 sqlite_command("PRAGMA journal_mode = WAL");
583 sqlite_command("PRAGMA synchronous = OFF");
584 sqlite_command("PRAGMA secure_delete = FAST");
585 sqlite_command("PRAGMA busy_timeout = 2147483647");
586 sqlite_command("PRAGMA foreign_keys = ON");
587
588 if (exists) {
589 if (get_db_version() < SINDEX_DATABASE_VERSION)
590 semind_error(1, 0, "%s: Database too old. Please rebuild it.", filename);
591 return;
592 }
593
594 set_db_version();
595
596 for (int i = 0; database_schema[i]; i++)
597 sqlite_command(database_schema[i]);
598 }
599
600 struct index_record {
601 const char *context;
602 int ctx_len;
603
604 const char *symbol;
605 int sym_len;
606
607 int kind;
608 unsigned int mode;
609 long long mtime;
610 sqlite3_int64 file;
611 int line;
612 int col;
613 };
614
615 static void insert_record(struct index_record *rec)
616 {
617 sqlite_bind_text(insert_rec_stmt, "@context", rec->context, rec->ctx_len);
618 sqlite_bind_text(insert_rec_stmt, "@symbol", rec->symbol, rec->sym_len);
619 sqlite_bind_int64(insert_rec_stmt, "@kind", rec->kind);
620 sqlite_bind_int64(insert_rec_stmt, "@mode", rec->mode);
621 sqlite_bind_int64(insert_rec_stmt, "@file", rec->file);
622 sqlite_bind_int64(insert_rec_stmt, "@line", rec->line);
623 sqlite_bind_int64(insert_rec_stmt, "@column", rec->col);
624 sqlite_run(insert_rec_stmt);
625 sqlite_reset_stmt(insert_rec_stmt);
626 }
627
628 static void update_stream(void)
629 {
630 if (semind_streams_nr >= input_stream_nr)
631 return;
632
633 semind_streams = realloc(semind_streams, input_stream_nr * sizeof(struct semind_streams));
634 if (!semind_streams)
635 semind_error(1, errno, "realloc");
636
637 sqlite_run(lock_stmt);
638
639 for (int i = semind_streams_nr; i < input_stream_nr; i++) {
640 struct stat st;
641 const char *filename;
642 char fullname[PATH_MAX];
643 sqlite3_int64 cur_mtime = 0;
644
645 if (input_streams[i].fd != -1) {
646 /*
647 * FIXME: Files in the input_streams may be duplicated.
648 */
649 if (stat(input_streams[i].name, &st) < 0)
650 semind_error(1, errno, "stat: %s", input_streams[i].name);
651
652 cur_mtime = st.st_mtime;
653
654 if (!realpath(input_streams[i].name, fullname))
655 semind_error(1, errno, "realpath: %s", input_streams[i].name);
656
657 if (!strncmp(fullname, cwd, n_cwd) && fullname[n_cwd] == '/') {
658 filename = fullname + n_cwd + 1;
659 semind_streams[i].id = 0;
660 } else {
661 semind_streams[i].id = -1;
662 continue;
663 }
664 } else {
665 semind_streams[i].id = -1;
666 continue;
667 }
668
669 if (semind_verbose > 1)
670 message("filename: %s", filename);
671
672 sqlite_bind_text(select_file_stmt, "@name", filename, -1);
673
674 if (sqlite_run(select_file_stmt) == SQLITE_ROW) {
675 sqlite3_int64 old_mtime;
676
677 semind_streams[i].id = sqlite3_column_int64(select_file_stmt, 0);
678 old_mtime = sqlite3_column_int64(select_file_stmt, 1);
679
680 sqlite_reset_stmt(select_file_stmt);
681
682 if (cur_mtime == old_mtime)
683 continue;
684
685 sqlite_bind_text(delete_file_stmt, "@name", filename, -1);
686 sqlite_run(delete_file_stmt);
687 sqlite_reset_stmt(delete_file_stmt);
688 }
689
690 sqlite_reset_stmt(select_file_stmt);
691
692 sqlite_bind_text(insert_file_stmt, "@name", filename, -1);
693 sqlite_bind_int64(insert_file_stmt, "@mtime", cur_mtime);
694 sqlite_run(insert_file_stmt);
695 sqlite_reset_stmt(insert_file_stmt);
696
697 semind_streams[i].id = sqlite3_last_insert_rowid(semind_db);
698 }
699
700 sqlite_run(unlock_stmt);
701
702 semind_streams_nr = input_stream_nr;
703 }
704
705 static void r_symbol(unsigned mode, struct position *pos, struct symbol *sym)
706 {
707 static struct ident null;
708 struct ident *ctx = &null;
709 struct index_record rec;
710
711 update_stream();
712
713 if (semind_streams[pos->stream].id == -1)
714 return;
715
716 if (!semind_include_local_syms && sym_is_local(sym))
717 return;
718
719 if (!sym->ident) {
720 warning(*pos, "empty ident");
721 return;
722 }
723
724 if (dissect_ctx)
725 ctx = dissect_ctx->ident;
726
727 rec.context = ctx->name;
728 rec.ctx_len = ctx->len;
729 rec.symbol = sym->ident->name;
730 rec.sym_len = sym->ident->len;
731 rec.kind = sym->kind;
732 rec.mode = mode;
733 rec.file = semind_streams[pos->stream].id;
734 rec.line = pos->line;
735 rec.col = pos->pos;
736
737 insert_record(&rec);
738 }
739
740 static void r_member(unsigned mode, struct position *pos, struct symbol *sym, struct symbol *mem)
741 {
742 static struct ident null;
743 static char memname[1024];
744 struct ident *ni, *si, *mi;
745 struct ident *ctx = &null;
746 struct index_record rec;
747
748 update_stream();
749
750 if (semind_streams[pos->stream].id == -1)
751 return;
752
753 if (!semind_include_local_syms && sym_is_local(sym))
754 return;
755
756 ni = built_in_ident("?");
757 si = sym->ident ?: ni;
758 /* mem == NULL means entire struct accessed */
759 mi = mem ? (mem->ident ?: ni) : built_in_ident("*");
760
761 if (dissect_ctx)
762 ctx = dissect_ctx->ident;
763
764 snprintf(memname, sizeof(memname), "%.*s.%.*s", si->len, si->name, mi->len, mi->name);
765
766 rec.context = ctx->name;
767 rec.ctx_len = ctx->len;
768 rec.symbol = memname;
769 rec.sym_len = si->len + mi->len + 1;
770 rec.kind = 'm';
771 rec.mode = mode;
772 rec.file = semind_streams[pos->stream].id;
773 rec.line = pos->line;
774 rec.col = pos->pos;
775
776 insert_record(&rec);
777 }
778
779 static void r_symdef(struct symbol *sym)
780 {
781 r_symbol(U_DEF, &sym->pos, sym);
782 }
783
784 static void r_memdef(struct symbol *sym, struct symbol *mem)
785 {
786 r_member(U_DEF, &mem->pos, sym, mem);
787 }
788
789 static void command_add(int argc, char **argv)
790 {
791 static struct reporter reporter = {
792 .r_symdef = r_symdef,
793 .r_symbol = r_symbol,
794 .r_memdef = r_memdef,
795 .r_member = r_member,
796 };
797
798 open_temp_database();
799
800 sqlite_prepare_persistent(
801 "BEGIN IMMEDIATE",
802 &lock_stmt);
803
804 sqlite_prepare_persistent(
805 "COMMIT",
806 &unlock_stmt);
807
808 sqlite_prepare_persistent(
809 "INSERT OR IGNORE INTO tempdb.semind "
810 "(context, symbol, kind, mode, file, line, column) "
811 "VALUES (@context, @symbol, @kind, @mode, @file, @line, @column)",
812 &insert_rec_stmt);
813
814 sqlite_prepare_persistent(
815 "SELECT id, mtime FROM file WHERE name == @name",
816 &select_file_stmt);
817
818 sqlite_prepare_persistent(
819 "INSERT INTO file (name, mtime) VALUES (@name, @mtime)",
820 &insert_file_stmt);
821
822 sqlite_prepare_persistent(
823 "DELETE FROM file WHERE name == @name",
824 &delete_file_stmt);
825
826 dissect(&reporter, semind_filelist);
827
828 sqlite_run(lock_stmt);
829 sqlite_command("INSERT OR IGNORE INTO semind SELECT * FROM tempdb.semind");
830 sqlite_run(unlock_stmt);
831
832 sqlite3_finalize(insert_rec_stmt);
833 sqlite3_finalize(select_file_stmt);
834 sqlite3_finalize(insert_file_stmt);
835 sqlite3_finalize(delete_file_stmt);
836 sqlite3_finalize(lock_stmt);
837 sqlite3_finalize(unlock_stmt);
838 free(semind_streams);
839 }
840
841 static void command_rm(int argc, char **argv)
842 {
843 sqlite3_stmt *stmt;
844
845 sqlite_command("BEGIN IMMEDIATE");
846 sqlite_prepare("DELETE FROM file WHERE name GLOB @file", &stmt);
847
848 if (semind_verbose > 1)
849 message("SQL: %s", sqlite3_sql(stmt));
850
851 for (int i = 0; i < argc; i++) {
852 sqlite_bind_text(stmt, "@file", argv[i], -1);
853 sqlite_run(stmt);
854 sqlite_reset_stmt(stmt);
855 }
856
857 sqlite3_finalize(stmt);
858 sqlite_command("COMMIT");
859 }
860
861 static inline void print_mode(char *value)
862 {
863 char str[3];
864 int v = atoi(value);
865
866 if (v == U_DEF) {
867 printf("def");
868 return;
869 }
870
871 #define U(m) "-rwm"[(v / m) & 3]
872 str[0] = U(U_R_AOF);
873 str[1] = U(U_R_VAL);
874 str[2] = U(U_R_PTR);
875
876 printf("%.3s", str);
877 #undef U
878 }
879
880 static char *semind_file_name;
881 static FILE *semind_file_fd;
882 static int semind_file_lnum;
883 static char *semind_line;
884 static size_t semind_line_buflen;
885 static int semind_line_len;
886
887 static void print_file_line(const char *name, int lnum)
888 {
889 /*
890 * All files are sorted by name and line number. So, we can reopen
891 * the file and read it line by line.
892 */
893 if (!semind_file_name || strcmp(semind_file_name, name)) {
894 if (semind_file_fd) {
895 fclose(semind_file_fd);
896 free(semind_file_name);
897 }
898
899 semind_file_name = strdup(name);
900
901 if (!semind_file_name)
902 semind_error(1, errno, "strdup");
903
904 semind_file_fd = fopen(name, "r");
905
906 if (!semind_file_fd)
907 semind_error(1, errno, "fopen: %s", name);
908
909 semind_file_lnum = 0;
910 }
911
912 do {
913 if (semind_file_lnum == lnum) {
914 if (semind_line[semind_line_len-1] == '\n')
915 semind_line_len--;
916 printf("%.*s", semind_line_len, semind_line);
917 break;
918 }
919 semind_file_lnum++;
920 errno = 0;
921 } while((semind_line_len = getline(&semind_line, &semind_line_buflen, semind_file_fd)) != -1);
922
923 if (errno && errno != EOF)
924 semind_error(1, errno, "getline");
925 }
926
927 static int search_query_callback(void *data, int argc, char **argv, char **colname)
928 {
929 char *fmt = (char *) semind_search_format;
930 char buf[32];
931 int quote = 0;
932 int n = 0;
933
934 while (*fmt != '\0') {
935 char c = *fmt;
936
937 if (quote) {
938 quote = 0;
939 switch (c) {
940 case 't': c = '\t'; break;
941 case 'r': c = '\r'; break;
942 case 'n': c = '\n'; break;
943 }
944 } else if (c == '%') {
945 int colnum = 0;
946 char *pos = ++fmt;
947
948 c = *fmt;
949
950 if (c == '\0')
951 semind_error(1, 0, "unexpected end of format string");
952
953 switch (c) {
954 case 'f': colnum = 0; goto print_string;
955 case 'l': colnum = 1; goto print_string;
956 case 'c': colnum = 2; goto print_string;
957 case 'C': colnum = 3; goto print_string;
958 case 'n': colnum = 4; goto print_string;
959 case 'm':
960 if (n) {
961 printf("%.*s", n, buf);
962 n = 0;
963 }
964 print_mode(argv[5]);
965 fmt++;
966 break;
967 case 'k':
968 if (n) {
969 printf("%.*s", n, buf);
970 n = 0;
971 }
972 printf("%c", atoi(argv[6]));
973 fmt++;
974 break;
975 case 's':
976 if (n) {
977 printf("%.*s", n, buf);
978 n = 0;
979 }
980 print_file_line(argv[0], atoi(argv[1]));
981 fmt++;
982 break;
983
984 print_string:
985 if (n) {
986 printf("%.*s", n, buf);
987 n = 0;
988 }
989 printf("%s", argv[colnum]);
990 fmt++;
991 break;
992 default:
993 break;
994
995 }
996
997 if (pos == fmt)
998 semind_error(1, 0, "invalid format specification: %%%c", c);
999
1000 continue;
1001 } else if (c == '\\') {
1002 quote = 1;
1003 fmt++;
1004 continue;
1005 }
1006
1007 if (n == sizeof(buf)) {
1008 printf("%.*s", n, buf);
1009 n = 0;
1010 }
1011
1012 buf[n++] = c;
1013 fmt++;
1014 }
1015
1016 if (n)
1017 printf("%.*s", n, buf);
1018 printf("\n");
1019
1020 return 0;
1021 }
1022
1023 static void command_search(int argc, char **argv)
1024 {
1025 char *sql;
1026 char *dberr = NULL;
1027 sqlite3_str *query = sqlite3_str_new(semind_db);
1028
1029 if (chdir(cwd) < 0)
1030 semind_error(1, errno, "unable to change directory: %s", cwd);
1031
1032 if (query_appendf(query,
1033 "SELECT"
1034 " file.name,"
1035 " semind.line,"
1036 " semind.column,"
1037 " semind.context,"
1038 " semind.symbol,"
1039 " semind.mode,"
1040 " semind.kind "
1041 "FROM semind, file "
1042 "WHERE semind.file == file.id") < 0)
1043 goto fail;
1044
1045 if (semind_search_kind) {
1046 if (query_appendf(query, " AND semind.kind == %d", semind_search_kind) < 0)
1047 goto fail;
1048 }
1049
1050 if (semind_search_symbol) {
1051 int ret;
1052
1053 if (query_appendf(query, " AND ") < 0)
1054 goto fail;
1055
1056 if (strpbrk(semind_search_symbol, "*?[]"))
1057 ret = query_appendf(query, "semind.symbol GLOB %Q", semind_search_symbol);
1058 else
1059 ret = query_appendf(query, "semind.symbol == %Q", semind_search_symbol);
1060
1061 if (ret < 0)
1062 goto fail;
1063 }
1064
1065 if (semind_search_modmask_defined) {
1066 if (!semind_search_modmask) {
1067 if (query_appendf(query, " AND semind.mode == %d", semind_search_modmask) < 0)
1068 goto fail;
1069 } else if (query_appendf(query, " AND (semind.mode & %d) != 0", semind_search_modmask) < 0)
1070 goto fail;
1071 }
1072
1073 if (semind_search_path) {
1074 if (query_appendf(query, " AND file.name GLOB %Q", semind_search_path) < 0)
1075 goto fail;
1076 }
1077
1078 if (semind_search_by_location == EXPLAIN_LOCATION) {
1079 if (query_appendf(query, " AND file.name == %Q", semind_search_filename) < 0)
1080 goto fail;
1081 if (semind_search_line &&
1082 query_appendf(query, " AND semind.line == %d", semind_search_line) < 0)
1083 goto fail;
1084 if (semind_search_column &&
1085 query_appendf(query, " AND semind.column == %d", semind_search_column) < 0)
1086 goto fail;
1087 } else if (semind_search_by_location == USAGE_BY_LOCATION) {
1088 if (query_appendf(query, " AND semind.symbol IN (") < 0)
1089 goto fail;
1090 if (query_appendf(query,
1091 "SELECT semind.symbol FROM semind, file WHERE"
1092 " semind.file == file.id AND"
1093 " file.name == %Q", semind_search_filename) < 0)
1094 goto fail;
1095 if (semind_search_line &&
1096 query_appendf(query, " AND semind.line == %d", semind_search_line) < 0)
1097 goto fail;
1098 if (semind_search_column &&
1099 query_appendf(query, " AND semind.column == %d", semind_search_column) < 0)
1100 goto fail;
1101 if (query_appendf(query, ")") < 0)
1102 goto fail;
1103 }
1104
1105 if (query_appendf(query, " ORDER BY file.name, semind.line, semind.column ASC", semind_search_path) < 0)
1106 goto fail;
1107
1108 sql = sqlite3_str_value(query);
1109
1110 if (semind_verbose > 1)
1111 message("SQL: %s", sql);
1112
1113 sqlite3_exec(semind_db, sql, search_query_callback, NULL, &dberr);
1114 if (dberr)
1115 semind_error(1, 0, "sql query failed: %s", dberr);
1116 fail:
1117 sql = sqlite3_str_finish(query);
1118 sqlite3_free(sql);
1119
1120 if (semind_file_fd) {
1121 fclose(semind_file_fd);
1122 free(semind_file_name);
1123 }
1124 free(semind_line);
1125 }
1126
1127
1128 int main(int argc, char **argv)
1129 {
1130 static const struct command commands[] = {
1131 {
1132 .name = "add",
1133 .dbflags = SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE,
1134 .parse_cmdline = parse_cmdline_add,
1135 .handler = command_add
1136 },
1137 {
1138 .name = "rm",
1139 .dbflags = SQLITE_OPEN_READWRITE,
1140 .parse_cmdline = parse_cmdline_rm,
1141 .handler = command_rm
1142 },
1143 {
1144 .name = "search",
1145 .dbflags = SQLITE_OPEN_READONLY,
1146 .parse_cmdline = parse_cmdline_search,
1147 .handler = command_search
1148 },
1149 { .name = NULL },
1150 };
1151 const struct command *cmd;
1152
1153 if (!(progname = rindex(argv[0], '/')))
1154 progname = argv[0];
1155 else
1156 progname++;
1157
1158 if (!realpath(".", cwd))
1159 semind_error(1, errno, "unable to get current directory");
1160 n_cwd = strlen(cwd);
1161
1162 parse_cmdline(argc, argv);
1163
1164 for (cmd = commands; cmd->name && strcmp(argv[optind], cmd->name); cmd++);
1165 if (!cmd->name)
1166 semind_error(1, 0, "unknown command: %s", argv[optind]);
1167 optind++;
1168
1169 semind_command = cmd->name;
1170
1171 if (cmd->parse_cmdline)
1172 cmd->parse_cmdline(argc, argv);
1173
1174 open_database(semind_dbfile, cmd->dbflags);
1175 cmd->handler(argc - optind, argv + optind);
1176
1177 sqlite3_close(semind_db);
1178
1179 return 0;
1180 }
Static analysis for C