Print this page
5292 findunref is both slow and broken
| Split |
Close |
| Expand all |
| Collapse all |
--- old/usr/src/tools/findunref/findunref.c
+++ new/usr/src/tools/findunref/findunref.c
1 1 /*
2 2 * CDDL HEADER START
3 3 *
4 4 * The contents of this file are subject to the terms of the
5 5 * Common Development and Distribution License (the "License").
6 6 * You may not use this file except in compliance with the License.
7 7 *
8 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 9 * or http://www.opensolaris.org/os/licensing.
10 10 * See the License for the specific language governing permissions
11 11 * and limitations under the License.
12 12 *
13 13 * When distributing Covered Code, include this CDDL HEADER in each
14 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 15 * If applicable, add the following below this CDDL HEADER, with the
16 16 * fields enclosed by brackets "[]" replaced with your own identifying
17 17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 18 *
19 19 * CDDL HEADER END
20 20 *
21 21 * Copyright 2009 Sun Microsystems, Inc. All rights reserved.
22 22 * Use is subject to license terms.
23 23 */
24 24
25 25 /*
26 26 * Finds all unreferenced files in a source tree that do not match a list of
27 27 * permitted pathnames.
28 28 */
29 29
30 30 #include <ctype.h>
31 31 #include <errno.h>
32 32 #include <fnmatch.h>
33 33 #include <ftw.h>
34 34 #include <stdarg.h>
35 35 #include <stdio.h>
36 36 #include <stdlib.h>
37 37 #include <string.h>
38 38 #include <time.h>
39 39 #include <unistd.h>
40 40 #include <sys/param.h>
41 41 #include <sys/stat.h>
42 42 #include <sys/types.h>
43 43
44 44 /*
45 45 * Pathname set: a simple datatype for storing pathname pattern globs and
|
↓ open down ↓ |
45 lines elided |
↑ open up ↑ |
46 46 * for checking whether a given pathname is matched by a pattern glob in
47 47 * the set.
48 48 */
49 49 typedef struct {
50 50 char **paths;
51 51 unsigned int npath;
52 52 unsigned int maxpaths;
53 53 } pnset_t;
54 54
55 55 /*
56 - * Data associated with the current Mercurial manifest.
56 + * Data associated with the current SCM manifest.
57 57 */
58 -typedef struct hgdata {
58 +typedef struct scmdata {
59 59 pnset_t *manifest;
60 - char hgpath[MAXPATHLEN];
60 + char metapath[MAXPATHLEN];
61 61 char root[MAXPATHLEN];
62 62 unsigned int rootlen;
63 63 boolean_t rootwarn;
64 -} hgdata_t;
64 +} scmdata_t;
65 65
66 66 /*
67 67 * Hooks used to check if a given unreferenced file is known to an SCM
68 - * (currently Mercurial and TeamWare).
68 + * (currently Git, Mercurial and TeamWare).
69 69 */
70 70 typedef int checkscm_func_t(const char *, const struct FTW *);
71 71 typedef void chdirscm_func_t(const char *);
72 72
73 73 typedef struct {
74 74 const char *name;
75 75 checkscm_func_t *checkfunc;
76 76 chdirscm_func_t *chdirfunc;
77 77 } scm_t;
78 78
79 -static checkscm_func_t check_tw, check_hg, check_git;
79 +static checkscm_func_t check_tw, check_scmdata;
80 80 static chdirscm_func_t chdir_hg, chdir_git;
81 81 static int pnset_add(pnset_t *, const char *);
82 82 static int pnset_check(const pnset_t *, const char *);
83 83 static void pnset_empty(pnset_t *);
84 84 static void pnset_free(pnset_t *);
85 85 static int checkpath(const char *, const struct stat *, int, struct FTW *);
86 86 static pnset_t *make_exset(const char *);
87 87 static void warn(const char *, ...);
88 88 static void die(const char *, ...);
89 89
90 90 static const scm_t scms[] = {
91 91 { "tw", check_tw, NULL },
92 92 { "teamware", check_tw, NULL },
93 - { "hg", check_hg, chdir_hg },
94 - { "mercurial", check_hg, chdir_hg },
95 - { "git", check_git, chdir_git },
93 + { "hg", check_scmdata, chdir_hg },
94 + { "mercurial", check_scmdata, chdir_hg },
95 + { "git", check_scmdata, chdir_git },
96 96 { NULL, NULL, NULL }
97 97 };
98 98
99 99 static const scm_t *scm;
100 -static hgdata_t hgdata;
101 -static pnset_t *gitmanifest = NULL;
100 +static scmdata_t scmdata;
102 101 static time_t tstamp; /* timestamp to compare files to */
103 102 static pnset_t *exsetp; /* pathname globs to ignore */
104 103 static const char *progname;
105 104
106 105 int
107 106 main(int argc, char *argv[])
108 107 {
109 108 int c;
110 109 char path[MAXPATHLEN];
111 110 char subtree[MAXPATHLEN] = "./";
112 111 char *tstampfile = ".build.tstamp";
113 112 struct stat tsstat;
114 113
115 114 progname = strrchr(argv[0], '/');
116 115 if (progname == NULL)
117 116 progname = argv[0];
118 117 else
119 118 progname++;
120 119
121 120 while ((c = getopt(argc, argv, "as:t:S:")) != EOF) {
122 121 switch (c) {
123 122 case 'a':
124 123 /* for compatibility; now the default */
125 124 break;
126 125
127 126 case 's':
128 127 (void) strlcat(subtree, optarg, MAXPATHLEN);
129 128 break;
130 129
131 130 case 't':
132 131 tstampfile = optarg;
133 132 break;
134 133
135 134 case 'S':
136 135 for (scm = scms; scm->name != NULL; scm++) {
137 136 if (strcmp(scm->name, optarg) == 0)
138 137 break;
139 138 }
140 139 if (scm->name == NULL)
141 140 die("unsupported SCM `%s'\n", optarg);
142 141 break;
143 142
144 143 default:
145 144 case '?':
146 145 goto usage;
147 146 }
148 147 }
149 148
150 149 argc -= optind;
151 150 argv += optind;
152 151
153 152 if (argc != 2) {
154 153 usage: (void) fprintf(stderr, "usage: %s [-s <subtree>] "
155 154 "[-t <tstampfile>] [-S hg|tw|git] <srcroot> <exceptfile>\n",
156 155 progname);
157 156 return (EXIT_FAILURE);
158 157 }
159 158
160 159 /*
161 160 * Interpret a relative timestamp path as relative to srcroot.
162 161 */
163 162 if (tstampfile[0] == '/')
164 163 (void) strlcpy(path, tstampfile, MAXPATHLEN);
165 164 else
166 165 (void) snprintf(path, MAXPATHLEN, "%s/%s", argv[0], tstampfile);
167 166
168 167 if (stat(path, &tsstat) == -1)
169 168 die("cannot stat timestamp file \"%s\"", path);
170 169 tstamp = tsstat.st_mtime;
171 170
172 171 /*
173 172 * Create the exception pathname set.
174 173 */
175 174 exsetp = make_exset(argv[1]);
176 175 if (exsetp == NULL)
177 176 die("cannot make exception pathname set\n");
178 177
179 178 /*
180 179 * Walk the specified subtree of the tree rooted at argv[0].
181 180 */
182 181 if (chdir(argv[0]) == -1)
183 182 die("cannot change directory to \"%s\"", argv[0]);
184 183
185 184 if (nftw(subtree, checkpath, 100, FTW_PHYS) != 0)
|
↓ open down ↓ |
74 lines elided |
↑ open up ↑ |
186 185 die("cannot walk tree rooted at \"%s\"\n", argv[0]);
187 186
188 187 pnset_empty(exsetp);
189 188 return (EXIT_SUCCESS);
190 189 }
191 190
192 191 /*
193 192 * Load and return a pnset for the manifest for the Mercurial repo at `hgroot'.
194 193 */
195 194 static pnset_t *
196 -load_manifest(const char *hgroot)
195 +hg_manifest(const char *hgroot)
197 196 {
198 197 FILE *fp = NULL;
199 198 char *hgcmd = NULL;
200 199 char *newline;
201 200 pnset_t *pnsetp;
202 201 char path[MAXPATHLEN];
203 202
204 203 pnsetp = calloc(sizeof (pnset_t), 1);
205 204 if (pnsetp == NULL ||
206 205 asprintf(&hgcmd, "hg manifest -R %s", hgroot) == -1)
207 206 goto fail;
208 207
209 208 fp = popen(hgcmd, "r");
210 209 if (fp == NULL)
211 210 goto fail;
212 211
213 212 while (fgets(path, sizeof (path), fp) != NULL) {
214 213 newline = strrchr(path, '\n');
215 214 if (newline != NULL)
216 215 *newline = '\0';
217 216
218 217 if (pnset_add(pnsetp, path) == 0)
219 218 goto fail;
220 219 }
221 220
222 221 (void) pclose(fp);
223 222 free(hgcmd);
|
↓ open down ↓ |
17 lines elided |
↑ open up ↑ |
224 223 return (pnsetp);
225 224 fail:
226 225 warn("cannot load hg manifest at %s", hgroot);
227 226 if (fp != NULL)
228 227 (void) pclose(fp);
229 228 free(hgcmd);
230 229 pnset_free(pnsetp);
231 230 return (NULL);
232 231 }
233 232
234 -static void
235 -chdir_git(const char *path)
233 +/*
234 + * Load and return a pnset for the manifest for the Git repo at `gitroot'.
235 + */
236 +static pnset_t *
237 +git_manifest(const char *gitroot)
236 238 {
237 - FILE *fp = NULL;
238 - char *gitcmd = NULL;
239 - char *newline;
240 - char fn[MAXPATHLEN];
241 - pnset_t *pnsetp;
239 + FILE *fp = NULL;
240 + char *gitcmd = NULL;
241 + char *newline;
242 + pnset_t *pnsetp;
243 + char path[MAXPATHLEN];
242 244
243 245 pnsetp = calloc(sizeof (pnset_t), 1);
244 - if ((pnsetp == NULL) ||
245 - (asprintf(&gitcmd, "git ls-files %s", path) == -1))
246 + if (pnsetp == NULL ||
247 + asprintf(&gitcmd, "git --git-dir=%s/.git ls-files", gitroot) == -1)
246 248 goto fail;
247 249
248 - if ((fp = popen(gitcmd, "r")) == NULL)
250 + fp = popen(gitcmd, "r");
251 + if (fp == NULL)
249 252 goto fail;
250 253
251 - while (fgets(fn, sizeof (fn), fp) != NULL) {
252 - if ((newline = strrchr(fn, '\n')) != NULL)
254 + while (fgets(path, sizeof (path), fp) != NULL) {
255 + newline = strrchr(path, '\n');
256 + if (newline != NULL)
253 257 *newline = '\0';
254 258
255 - if (pnset_add(pnsetp, fn) == 0)
259 + if (pnset_add(pnsetp, path) == 0)
256 260 goto fail;
257 261 }
258 262
259 263 (void) pclose(fp);
260 264 free(gitcmd);
261 - gitmanifest = pnsetp;
262 - return;
265 + return (pnsetp);
263 266 fail:
264 - warn("cannot load git manifest");
267 + warn("cannot load git manifest at %s", gitroot);
265 268 if (fp != NULL)
266 269 (void) pclose(fp);
267 - if (pnsetp != NULL)
268 - free(pnsetp);
269 - if (gitcmd != NULL)
270 - free(gitcmd);
270 + free(gitcmd);
271 + pnset_free(pnsetp);
272 + return (NULL);
271 273 }
272 274
273 275 /*
274 276 * If necessary, change our active manifest to be appropriate for `path'.
275 277 */
276 278 static void
277 -chdir_hg(const char *path)
279 +chdir_scmdata(const char *path, const char *meta,
280 + pnset_t *(*manifest_func)(const char *path))
278 281 {
279 - char hgpath[MAXPATHLEN];
282 + char scmpath[MAXPATHLEN];
280 283 char basepath[MAXPATHLEN];
281 284 char *slash;
282 285
283 - (void) snprintf(hgpath, MAXPATHLEN, "%s/.hg", path);
286 + (void) snprintf(scmpath, MAXPATHLEN, "%s/%s", path, meta);
284 287
285 288 /*
286 289 * Change our active manifest if any one of the following is true:
287 290 *
288 - * 1. No manifest is loaded. Find the nearest hgroot to load from.
291 + * 1. No manifest is loaded. Find the nearest SCM root to load from.
289 292 *
290 293 * 2. A manifest is loaded, but we've moved into a directory with
291 - * its own hgroot (e.g., usr/closed). Load from its hgroot.
294 + * its own metadata directory (e.g., usr/closed). Load from its
295 + * root.
292 296 *
293 297 * 3. A manifest is loaded, but no longer applies (e.g., the manifest
294 298 * under usr/closed is loaded, but we've moved to usr/src).
295 299 */
296 - if (hgdata.manifest == NULL ||
297 - strcmp(hgpath, hgdata.hgpath) != 0 && access(hgpath, X_OK) == 0 ||
298 - strncmp(path, hgdata.root, hgdata.rootlen - 1) != 0) {
299 - pnset_free(hgdata.manifest);
300 - hgdata.manifest = NULL;
300 + if (scmdata.manifest == NULL ||
301 + (strcmp(scmpath, scmdata.metapath) != 0 &&
302 + access(scmpath, X_OK) == 0) ||
303 + strncmp(path, scmdata.root, scmdata.rootlen - 1) != 0) {
304 + pnset_free(scmdata.manifest);
305 + scmdata.manifest = NULL;
301 306
302 307 (void) strlcpy(basepath, path, MAXPATHLEN);
303 308
304 309 /*
305 - * Walk up the directory tree looking for .hg subdirectories.
310 + * Walk up the directory tree looking for metadata
311 + * subdirectories.
306 312 */
307 - while (access(hgpath, X_OK) == -1) {
313 + while (access(scmpath, X_OK) == -1) {
308 314 slash = strrchr(basepath, '/');
309 315 if (slash == NULL) {
310 - if (!hgdata.rootwarn) {
311 - warn("no hg root for \"%s\"\n", path);
312 - hgdata.rootwarn = B_TRUE;
316 + if (!scmdata.rootwarn) {
317 + warn("no metadata directory "
318 + "for \"%s\"\n", path);
319 + scmdata.rootwarn = B_TRUE;
313 320 }
314 321 return;
315 322 }
316 323 *slash = '\0';
317 - (void) snprintf(hgpath, MAXPATHLEN, "%s/.hg", basepath);
324 + (void) snprintf(scmpath, MAXPATHLEN, "%s/%s", basepath,
325 + meta);
318 326 }
319 327
320 328 /*
321 - * We found a directory with an .hg subdirectory; record it
322 - * and load its manifest.
329 + * We found a directory with an SCM metadata directory; record
330 + * it and load its manifest.
323 331 */
324 - (void) strlcpy(hgdata.hgpath, hgpath, MAXPATHLEN);
325 - (void) strlcpy(hgdata.root, basepath, MAXPATHLEN);
326 - hgdata.manifest = load_manifest(hgdata.root);
332 + (void) strlcpy(scmdata.metapath, scmpath, MAXPATHLEN);
333 + (void) strlcpy(scmdata.root, basepath, MAXPATHLEN);
334 + scmdata.manifest = manifest_func(scmdata.root);
327 335
328 336 /*
329 - * The logic in check_hg() depends on hgdata.root having a
330 - * single trailing slash, so only add it if it's missing.
337 + * The logic in check_scmdata() depends on scmdata.root having
338 + * a single trailing slash, so only add it if it's missing.
331 339 */
332 - if (hgdata.root[strlen(hgdata.root) - 1] != '/')
333 - (void) strlcat(hgdata.root, "/", MAXPATHLEN);
334 - hgdata.rootlen = strlen(hgdata.root);
340 + if (scmdata.root[strlen(scmdata.root) - 1] != '/')
341 + (void) strlcat(scmdata.root, "/", MAXPATHLEN);
342 + scmdata.rootlen = strlen(scmdata.root);
335 343 }
336 344 }
337 345
346 +static void
347 +chdir_git(const char *path)
348 +{
349 + chdir_scmdata(path, ".git", git_manifest);
350 +}
351 +
338 352 /*
339 - * Check if a file is under Mercurial control by checking against the manifest.
353 + * If necessary, change our active manifest to be appropriate for `path'.
340 354 */
355 +static void
356 +chdir_hg(const char *path)
357 +{
358 + chdir_scmdata(path, ".hg", hg_manifest);
359 +}
360 +
341 361 /* ARGSUSED */
342 362 static int
343 -check_hg(const char *path, const struct FTW *ftwp)
363 +check_scmdata(const char *path, const struct FTW *ftwp)
344 364 {
345 365 /*
346 366 * The manifest paths are relative to the manifest root; skip past it.
347 367 */
348 - path += hgdata.rootlen;
368 + path += scmdata.rootlen;
349 369
350 - return (hgdata.manifest != NULL && pnset_check(hgdata.manifest, path));
351 -}
352 -/* ARGSUSED */
353 -static int
354 -check_git(const char *path, const struct FTW *ftwp)
355 -{
356 - path += 2; /* Skip "./" */
357 - return (gitmanifest != NULL && pnset_check(gitmanifest, path));
370 + return (scmdata.manifest != NULL && pnset_check(scmdata.manifest,
371 + path));
358 372 }
359 373
360 374 /*
361 375 * Check if a file is under TeamWare control by checking for its corresponding
362 376 * SCCS "s-dot" file.
363 377 */
364 378 static int
365 379 check_tw(const char *path, const struct FTW *ftwp)
366 380 {
367 381 char sccspath[MAXPATHLEN];
368 382
369 383 (void) snprintf(sccspath, MAXPATHLEN, "%.*s/SCCS/s.%s", ftwp->base,
370 384 path, path + ftwp->base);
371 385
372 386 return (access(sccspath, F_OK) == 0);
373 387 }
374 388
375 389 /*
376 390 * Using `exceptfile' and a built-in list of exceptions, build and return a
377 391 * pnset_t consisting of all of the pathnames globs which are allowed to be
378 392 * unreferenced in the source tree.
379 393 */
380 394 static pnset_t *
381 395 make_exset(const char *exceptfile)
382 396 {
383 397 FILE *fp;
384 398 char line[MAXPATHLEN];
385 399 char *newline;
386 400 pnset_t *pnsetp;
387 401 unsigned int i;
388 402
389 403 pnsetp = calloc(sizeof (pnset_t), 1);
390 404 if (pnsetp == NULL)
391 405 return (NULL);
392 406
393 407 /*
394 408 * Add any exceptions from the file.
395 409 */
396 410 fp = fopen(exceptfile, "r");
397 411 if (fp == NULL) {
398 412 warn("cannot open exception file \"%s\"", exceptfile);
399 413 goto fail;
400 414 }
401 415
402 416 while (fgets(line, sizeof (line), fp) != NULL) {
403 417 newline = strrchr(line, '\n');
404 418 if (newline != NULL)
405 419 *newline = '\0';
406 420
407 421 for (i = 0; isspace(line[i]); i++)
408 422 ;
409 423
410 424 if (line[i] == '#' || line[i] == '\0')
411 425 continue;
412 426
413 427 if (pnset_add(pnsetp, line) == 0) {
414 428 (void) fclose(fp);
415 429 goto fail;
416 430 }
417 431 }
418 432
419 433 (void) fclose(fp);
420 434 return (pnsetp);
421 435 fail:
422 436 pnset_free(pnsetp);
423 437 return (NULL);
424 438 }
425 439
426 440 /*
427 441 * FTW callback: print `path' if it's older than `tstamp' and not in `exsetp'.
428 442 */
429 443 static int
430 444 checkpath(const char *path, const struct stat *statp, int type,
431 445 struct FTW *ftwp)
432 446 {
433 447 switch (type) {
434 448 case FTW_F:
435 449 /*
436 450 * Skip if the file is referenced or in the exception list.
437 451 */
438 452 if (statp->st_atime >= tstamp || pnset_check(exsetp, path))
439 453 return (0);
440 454
441 455 /*
442 456 * If requested, restrict ourselves to unreferenced files
443 457 * under SCM control.
444 458 */
445 459 if (scm == NULL || scm->checkfunc(path, ftwp))
446 460 (void) puts(path);
447 461 return (0);
448 462
449 463 case FTW_D:
450 464 /*
451 465 * Prune any directories in the exception list.
452 466 */
453 467 if (pnset_check(exsetp, path)) {
454 468 ftwp->quit = FTW_PRUNE;
455 469 return (0);
456 470 }
457 471
458 472 /*
459 473 * If necessary, advise the SCM logic of our new directory.
460 474 */
461 475 if (scm != NULL && scm->chdirfunc != NULL)
462 476 scm->chdirfunc(path);
463 477
464 478 return (0);
465 479
466 480 case FTW_DNR:
467 481 warn("cannot read \"%s\"", path);
468 482 return (0);
469 483
470 484 case FTW_NS:
471 485 warn("cannot stat \"%s\"", path);
472 486 return (0);
473 487
474 488 default:
475 489 break;
476 490 }
477 491
478 492 return (0);
479 493 }
480 494
481 495 /*
482 496 * Add `path' to the pnset_t pointed to by `pnsetp'.
483 497 */
484 498 static int
485 499 pnset_add(pnset_t *pnsetp, const char *path)
486 500 {
487 501 char **newpaths;
488 502 unsigned int maxpaths;
489 503
490 504 if (pnsetp->npath == pnsetp->maxpaths) {
491 505 maxpaths = (pnsetp->maxpaths == 0) ? 512 : pnsetp->maxpaths * 2;
492 506 newpaths = realloc(pnsetp->paths, sizeof (char *) * maxpaths);
493 507 if (newpaths == NULL)
494 508 return (0);
495 509 pnsetp->paths = newpaths;
496 510 pnsetp->maxpaths = maxpaths;
497 511 }
498 512
499 513 pnsetp->paths[pnsetp->npath] = strdup(path);
500 514 if (pnsetp->paths[pnsetp->npath] == NULL)
501 515 return (0);
502 516
503 517 pnsetp->npath++;
504 518 return (1);
505 519 }
506 520
507 521 /*
508 522 * Check `path' against the pnset_t pointed to by `pnsetp'.
509 523 */
510 524 static int
511 525 pnset_check(const pnset_t *pnsetp, const char *path)
512 526 {
513 527 unsigned int i;
514 528
515 529 for (i = 0; i < pnsetp->npath; i++) {
516 530 if (fnmatch(pnsetp->paths[i], path, 0) == 0)
517 531 return (1);
518 532 }
519 533 return (0);
520 534 }
521 535
522 536 /*
523 537 * Empty the pnset_t pointed to by `pnsetp'.
524 538 */
525 539 static void
526 540 pnset_empty(pnset_t *pnsetp)
527 541 {
528 542 while (pnsetp->npath-- != 0)
529 543 free(pnsetp->paths[pnsetp->npath]);
530 544
531 545 free(pnsetp->paths);
532 546 pnsetp->maxpaths = 0;
533 547 }
534 548
535 549 /*
536 550 * Free the pnset_t pointed to by `pnsetp'.
537 551 */
538 552 static void
539 553 pnset_free(pnset_t *pnsetp)
540 554 {
541 555 if (pnsetp != NULL) {
542 556 pnset_empty(pnsetp);
543 557 free(pnsetp);
544 558 }
545 559 }
546 560
547 561 /* PRINTFLIKE1 */
548 562 static void
549 563 warn(const char *format, ...)
550 564 {
551 565 va_list alist;
552 566 char *errstr = strerror(errno);
553 567
554 568 if (errstr == NULL)
555 569 errstr = "<unknown error>";
556 570
557 571 (void) fprintf(stderr, "%s: ", progname);
558 572
559 573 va_start(alist, format);
560 574 (void) vfprintf(stderr, format, alist);
561 575 va_end(alist);
562 576
563 577 if (strrchr(format, '\n') == NULL)
564 578 (void) fprintf(stderr, ": %s\n", errstr);
565 579 }
566 580
567 581 /* PRINTFLIKE1 */
568 582 static void
569 583 die(const char *format, ...)
570 584 {
571 585 va_list alist;
572 586 char *errstr = strerror(errno);
573 587
574 588 if (errstr == NULL)
575 589 errstr = "<unknown error>";
576 590
577 591 (void) fprintf(stderr, "%s: fatal: ", progname);
578 592
579 593 va_start(alist, format);
580 594 (void) vfprintf(stderr, format, alist);
581 595 va_end(alist);
582 596
583 597 if (strrchr(format, '\n') == NULL)
584 598 (void) fprintf(stderr, ": %s\n", errstr);
585 599
586 600 exit(EXIT_FAILURE);
587 601 }
|
↓ open down ↓ |
220 lines elided |
↑ open up ↑ |
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX