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