OSCR

<i>ADAMTS18</i> as a candidate gene linking social stress and depression: a cross-species study in African wild dogs (<i>Lycaon pictus</i>) and humans.

Code ↔ Paper

2 matches between paragraphs of the paper and lines of its authors' code, computed by the harvester (lexical-v1). Click a colored paragraph or line to see its counterpart.

The 2 matches
  1. [1] § Materials and methods › Processing of the sequencing data ↔ tools/loaders/bam-loader/bam-loader.c, lines 59–127 · score 0.67 · quality scores, mapping quality, Aligner, MAPQ, Duplicate, alignment
  2. [2] § Materials and methods › Processing of the sequencing data ↔ ngs/ngs-python/ngs/PileupEvent.py, lines 38–154 · score 0.57 · mapping quality, technology, deletions, insertions, INDELs, genomic

Paper

Loaded from Europe PMC by your browser, not stored by OSCR: doi.org · Europe PMC

The paper is loaded when this pane is shown.

The authors' code

C · 1,388 lines · 43 KB · other · 1 match

  1. /*===========================================================================
  2. *
  3. * PUBLIC DOMAIN NOTICE
  4. * National Center for Biotechnology Information
  5. *
  6. * This software/database is a "United States Government Work" under the
  7. * terms of the United States Copyright Act. It was written as part of
  8. * the author's official duties as a United States Government employee and
  9. * thus cannot be copyrighted. This software/database is freely available
  10. * to the public for use. The National Library of Medicine and the U.S.
  11. * Government have not placed any restriction on its use or reproduction.
  12. *
  13. * Although all reasonable efforts have been taken to ensure the accuracy
  14. * and reliability of the software and data, the NLM and the U.S.
  15. * Government do not and cannot warrant the performance or results that
  16. * may be obtained by using this software or data. The NLM and the U.S.
  17. * Government disclaim all warranties, express or implied, including
  18. * warranties of performance, merchantability or fitness for any particular
  19. * purpose.
  20. *
  21. * Please cite the author in any work or product based on this material.
  22. *
  23. * ===========================================================================
  24. *
  25. */
  26. #include <stdlib.h>
  28. #ifdef __cplusplus
  29. extern "C" {
  30. #endif
  32. #include <kapp/main.h>
  33. #include <kapp/args.h>
  34. #include <klib/text.h>
  35. #include <klib/log.h>
  36. #include <klib/out.h>
  37. #include <klib/status.h>
  38. #include <klib/rc.h>
  39. #include <klib/printf.h>
  40. #include <kfs/directory.h>
  41. #include <kfs/file.h>
  42. #include <kapp/log-xml.h>
  43. #include <align/writer-refseq.h>
  45. #include <stdlib.h>
  46. #include <stdio.h>
  47. #include <string.h>
  48. #include <ctype.h>
  49. #include <assert.h>
  50. #include <limits.h>
  52. #include "Globals.h"
  53. #ifdef __cplusplus
  54. }
  55. #endif
  57. #include "loader-imp.h"
  59. /*: ARGS
  60. Summary:
  61. Load a BAM formatted data file
  63. Usage:
  64. --help display this text and quit
  65. --version display the version string and quit
  66. [global-options] [options] <file...> [ --remap [options] <file>... ]...
  68. //:global-options
  69. Global Options:
  71. * options effecting logging
  72. log-level <level> logging level values: [fatal|sys|int|err|warn|info|0-5] default: info
  73. xml-log <filename> produce an XML-formatted log file
  75. * options effecting performance optimisation
  76. tmpfs <directory> where to store temparary files, default: '/tmp'
  77. cache-size <mbytes> the limit in MB for temparary files
  78. min-batch-size <number> minimum batch size for spot assembly (default 10e6)
  80. * options effecting error limits
  81. max-err-count <number> the maximum number of errors to ignore
  82. max-warning-dup-flag <count> the limit for number of duplicate flag mismatch warnings
  84. //:options
  85. Options:
  86. output <name> name of the output, required
  87. config <file> reference configuration file (See Configuration)
  88. header <file> file containing the SAM header
  89. remap special option to enable processing sets of remapped files. remap MUST be given between each set, all regular options can be respecified, in fact the output must be unique for each set. This is for when a set of reads are aligned multiple times, for example against different reference builds or with different aligners. This mode ensures that spot ids are the same across the several outputs.
  91. Debugging Options:
  92. only-verify exit after verifying existence of references
  93. max-rec-count <number> exit after processing this many records (per file)
  94. nomatch-log <path> log alignments with no matching bases
  96. Filtering Options:
  97. minimum-match <number> minimum number of matches for an alignment
  98. no-secondary ignore alignments marked as secondary
  99. accept-dups accept spots with inconsistent PCR duplicate flags
  100. accept-nomatch accept alignments with no matching bases
  101. ref-config limit processing to references in the config file, ignoring all others
  102. ref-filter <name> limit processing to the given reference, ignoring all others
  103. min-mapq <number> filter secondary alignments by minimum mapping quality
  105. Rare or Esoteric Options:
  106. input <directory> where to find fasta files
  107. ref-file <file> fasta file with references
  108. force-sorted disable sort-order checking
  109. unsorted expect unsorted input (requires more memory)
  110. sorted require sorted input
  111. TI look for trace id optional tag
  112. unaligned <file> file without aligned reads
  114. Deprecated Options:
  115. use-OQ use OQ option column for quality values instead of QUAL
  116. no-verify skip verify existence of references from the BAM file
  117. accept-hard-clip allow hard clipping in CIGAR
  118. allow-multi-map allow the same reference to be mapped to multiple names in the input files
  119. edit-aligned-qual <number> convert quality at aligned positions to this value
  120. cs turn on awareness of colorspace
  121. qual-quant quality scores quantization level
  122. keep-mismatch-qual don't quantized quality at mismatched positions
  125. Example:
  126. bam-load -o /tmp/SRZ123456 -k analysis.bam.cfg 123456.bam
  127. */
  129. /* MARK: Arguments and Usage */
  130. static char const option_input[] = "input";
  131. static char const option_output[] = "output";
  132. static char const option_tmpfs[] = "tmpfs";
  133. static char const option_config[] = "config";
  134. static char const option_min_mapq[] = "min-mapq";
  135. static char const option_qual_compress[] = "qual-quant";
  136. static char const option_cache_size[] = "cache-size";
  137. static char const option_no_sort_check[] = "force-sorted";
  138. static char const option_unsorted[] = "unsorted";
  139. static char const option_sorted[] = "sorted";
  140. static char const option_max_err_count[] = "max-err-count";
  141. static char const option_max_rec_count[] = "max-rec-count";
  142. static char const option_no_verify[] = "no-verify";
  143. static char const option_only_verify[] = "only-verify";
  144. static char const option_use_qual[] = "use-QUAL";
  145. static char const option_ref_filter[] = "ref-filter";
  146. static char const option_ref_config[] = "ref-config";
  147. static char const option_edit_aligned_qual[] = "edit-aligned-qual";
  148. static char const option_unaligned[] = "unaligned";
  149. static char const option_accept_dup[] = "accept-dups";
  150. static char const option_accept_nomatch[] = "accept-nomatch";
  151. static char const option_nomatch_log[] = "nomatch-log";
  152. static char const option_keep_mismatch_qual[] = "keep-mismatch-qual";
  153. static char const option_min_match[] = "minimum-match";
  154. static char const option_header[] = "header";
  155. static char const option_no_cs[] = "no-cs";
  156. static char const option_no_secondary[] = "no-secondary";
  157. static char const option_ref_file[] = "ref-file";
  158. static char const option_TI[] = "TI";
  159. static char const option_max_warn_dup_flag[] = "max-warning-dup-flag";
  160. static char const option_accept_hard_clip[] = "accept-hard-clip";
  161. static char const option_allow_multi_map[] = "allow-multi-map";
  162. static char const option_allow_secondary[] = "make-spots-with-secondary";
  163. static char const option_defer_secondary[] = "defer-secondary";
  164. static char const option_spot_batch_size[] = "batch-size";
  165. static char const option_threads[] = "threads";
  166. static char const option_extra_logging[] = "extra-logging";
  167. static char const option_min_batch_size[] = "min-batch-size";
  168. static char const option_telemetry[] = "telemetry";
  170. #define OPTION_INPUT option_input
  171. #define OPTION_OUTPUT option_output
  172. #define OPTION_TMPFS option_tmpfs
  173. #define OPTION_CONFIG option_config
  174. #define OPTION_MINMAPQ option_min_mapq
  175. #define OPTION_QCOMP option_qual_compress
  176. #define OPTION_CACHE_SIZE option_cache_size
  177. #define OPTION_MAX_ERR_COUNT option_max_err_count
  178. #define OPTION_MAX_REC_COUNT option_max_rec_count
  179. #define OPTION_UNALIGNED option_unaligned
  180. #define OPTION_ACCEPT_DUP option_accept_dup
  181. #define OPTION_ACCEPT_NOMATCH option_accept_nomatch
  182. #define OPTION_NOMATCH_LOG option_nomatch_log
  183. #define OPTION_MIN_MATCH option_min_match
  184. #define OPTION_HEADER option_header
  185. #define OPTION_NO_CS option_no_cs
  186. #define OPTION_NO_SECONDARY option_no_secondary
  187. #define OPTION_REF_FILE option_ref_file
  188. #define OPTION_TI option_TI
  189. #define OPTION_MAX_WARN_DUP_FLAG option_max_warn_dup_flag
  190. #define OPTION_ACCEPT_HARD_CLIP option_accept_hard_clip
  191. #define OPTION_ALLOW_MULTI_MAP option_allow_multi_map
  192. #define OPTION_ALLOW_SECONDARY option_allow_secondary
  193. #define OPTION_DEFER_SECONDARY option_defer_secondary
  194. #define OPTION_SPOT_BATCH_SIZE option_spot_batch_size
  195. #define OPTION_THREADS option_threads
  196. #define OPTION_EXTRA_LOGGING option_extra_logging
  197. #define OPTION_MIN_BATCH_SIZE option_min_batch_size
  198. #define OPTION_TELEMETRY option_telemetry
  201. #define ALIAS_INPUT "i"
  202. #define ALIAS_OUTPUT "o"
  203. #define ALIAS_TMPFS "t"
  204. #define ALIAS_CONFIG "k"
  205. #define ALIAS_MINMAPQ "q"
  206. #define ALIAS_QCOMP "Q"
  207. #define ALIAS_MAX_ERR_COUNT "E"
  208. #define ALIAS_UNALIGNED "u"
  209. #define ALIAS_ACCEPT_DUP "d"
  210. #define ALIAS_NO_SECONDARY "P"
  211. #define ALIAS_REF_FILE "r"
  213. static
  214. char const * input_usage[] =
  215. {
  216. "Path where to get fasta files from.",
  217. NULL
  218. };
  220. static
  221. char const * output_usage[] =
  222. {
  223. "Path and Name of the output database.",
  224. NULL
  225. };
  227. static
  228. char const * tmpfs_usage[] =
  229. {
  230. "Path to be used for scratch files.",
  231. NULL
  232. };
  234. static
  235. char const * config_usage[] =
  236. {
  237. "Path to configuration file:",
  238. "maps the input BAM file's reference names to the equivalent GenBank accession.",
  239. "It is a tab-delimited text file with unix line endings (\\n - LF) with the following fields in this order:",
  240. "#1 reference name as it occurs in the BAM file's SN field of @SQ header record;",
  241. "#2 INSDC reference ID",
  242. NULL
  243. };
  245. static
  246. char const * min_mapq_usage[] =
  247. {
  248. "Filter secondary alignments by minimum mapping quality.",
  249. NULL
  250. };
  252. static
  253. char const * qcomp_usage[] =
  254. {
  255. "Quality scores quantization level, can be a number (0: none, 1: 2bit, 2: 1bit), or a string like '1:10,10:20,20:30,30:-' (which is equivalent to 1) (nb. the endpoint is exclusive).",
  256. NULL
  257. };
  259. static
  260. char const * no_sort_usage[] =
  261. {
  262. "Disable sort order checking.",
  263. NULL
  264. };
  266. static
  267. char const * unsorted_usage[] =
  268. {
  269. "Tell the loader to expect unsorted input (requires more memory)",
  270. NULL
  271. };
  273. static
  274. char const * sorted_usage[] =
  275. {
  276. "Tell the loader to require sorted input",
  277. NULL
  278. };
  280. static
  281. char const * cache_size_usage[] =
  282. {
  283. "Set the cache size in MB for the temporary indices",
  284. NULL
  285. };
  287. static
  288. char const * mrc_usage[] =
  289. {
  290. "Set the maximum number of records to process from the BAM file",
  291. NULL
  292. };
  294. static
  295. char const * mec_usage[] =
  296. {
  297. "Set the maximum number of errors to ignore from the BAM file",
  298. NULL
  299. };
  301. static
  302. char const * no_verify_usage[] =
  303. {
  304. "Skip verify existence of references from the BAM file",
  305. NULL
  306. };
  308. static
  309. char const * only_verify_usage[] =
  310. {
  311. "Exit after verifying existence of references from the BAM file",
  312. NULL
  313. };
  315. static
  316. char const * use_QUAL_usage[] =
  317. {
  318. "use QUAL column for quality values (default is to use OQ if it is available)",
  319. NULL
  320. };
  322. static
  323. char const * use_ref_filter[] =
  324. {
  325. "Only process alignments to the given reference",
  326. NULL
  327. };
  329. static
  330. char const * use_ref_config[] =
  331. {
  332. "Only process alignments to references in the config file",
  333. NULL
  334. };
  336. static
  337. char const * use_edit_aligned_qual[] =
  338. {
  339. "Convert quality at aligned positions to this value",
  340. NULL
  341. };
  343. static
  344. char const * use_keep_mismatch_qual[] =
  345. {
  346. "Don't quantized quality at mismatched positions",
  347. NULL
  348. };
  350. static
  351. char const * use_unaligned[] =
  352. {
  353. "Specify file without aligned reads",
  354. NULL
  355. };
  357. static
  358. char const * use_accept_dups[] =
  359. {
  360. "Accept spots inconsistent PCR duplicate flags",
  361. NULL
  362. };
  364. static
  365. char const * use_accept_nomatch[] =
  366. {
  367. "Accept alignments with no matching bases",
  368. NULL
  369. };
  371. static
  372. char const * use_nomatch_log[] =
  373. {
  374. "Where to write info for alignments with no matching bases",
  375. NULL
  376. };
  378. static
  379. char const * use_min_match[] =
  380. {
  381. "minimum number of matches for an alignment",
  382. NULL
  383. };
  385. static
  386. char const * use_header[] =
  387. {
  388. "path to a file containing the SAM header to store in the resulting cSRA, recommended in case of multiple input BAMs",
  389. NULL
  390. };
  392. static
  393. char const * use_no_cs[] =
  394. {
  395. "turn off awareness of colorspace",
  396. NULL
  397. };
  399. static
  400. char const * use_no_secondary[] =
  401. {
  402. "ignore alignments marked as secondary",
  403. NULL
  404. };
  406. static
  407. char const * use_ref_file[] =
  408. {
  409. "path to a fasta file with references",
  410. NULL
  411. };
  413. static
  414. char const * use_TI[] =
  415. {
  416. "for trace alignments",
  417. NULL
  418. };
  420. static
  421. char const * use_max_dup_warnings[] =
  422. {
  423. "set limit for number of duplicate flag mismatch warnings",
  424. NULL
  425. };
  427. static
  428. char const * use_accept_hard_clip[] =
  429. {
  430. "accept hard clipping in CIGAR",
  431. NULL
  432. };
  434. static
  435. char const * use_allow_multi_map[] =
  436. {
  437. "allow the same reference to be mapped to multiple names in the input files",
  438. "(default is disallow, old behaviors was to allow it)",
  439. NULL
  440. };
  442. static
  443. char const * use_allow_secondary[] =
  444. {
  445. "use secondary alignments for constructing spots",
  446. NULL
  447. };
  449. static
  450. char const * use_defer_secondary[] =
  451. {
  452. "defer processing of secondary alignments until the end of the file",
  453. NULL
  454. };
  456. static
  457. char const * spot_batch_size[] =
  458. {
  459. "optional maximum size of the spot batches (default: 240e6)",
  460. NULL
  461. };
  463. static
  464. char const * number_of_threads[] =
  465. {
  466. "number of threads (3 or greater; can be 0, means default: 8)",
  467. NULL
  468. };
  470. static
  471. char const * is_extra_logging[] =
  472. {
  473. "extra_logging",
  474. NULL
  475. };
  477. static
  478. char const * min_batch_size_usage[] =
  479. {
  480. "Set the minimum batch size for spot assembly (default: 10,000,000 spots)",
  481. NULL
  482. };
  484. static
  485. char const * telemetry_usage[] =
  486. {
  487. "Path and Name of the telemetry file.",
  488. NULL
  489. };
  491. OptDef Options[] =
  492. {
  493. /* order here is same as in param array below!!! */
  494. { OPTION_INPUT, ALIAS_INPUT, NULL, input_usage, 1, true, false },
  495. { OPTION_OUTPUT, ALIAS_OUTPUT, NULL, output_usage, 1, true, true },
  496. { OPTION_CONFIG, ALIAS_CONFIG, NULL, config_usage, 1, true, false },
  497. { OPTION_HEADER, NULL, NULL, use_header, 1, true, false },
  498. { OPTION_TMPFS, ALIAS_TMPFS, NULL, tmpfs_usage, 1, true, false },
  499. { OPTION_UNALIGNED, ALIAS_UNALIGNED, NULL, use_unaligned, 256, true, false },
  500. { OPTION_ACCEPT_DUP, ALIAS_ACCEPT_DUP, NULL, use_accept_dups, 1, false, false },
  501. { OPTION_ACCEPT_NOMATCH, NULL, NULL, use_accept_nomatch, 1, false, false },
  502. { OPTION_NOMATCH_LOG, NULL, NULL, use_nomatch_log, 1, true, false },
  503. { OPTION_QCOMP, ALIAS_QCOMP, NULL, qcomp_usage, 1, true, false },
  504. { OPTION_MINMAPQ, ALIAS_MINMAPQ, NULL, min_mapq_usage, 1, true, false },
  505. { OPTION_CACHE_SIZE, NULL, NULL, cache_size_usage, 1, true, false },
  506. { OPTION_NO_CS, NULL, NULL, use_no_cs, 1, false, false },
  507. { OPTION_MIN_MATCH, NULL, NULL, use_min_match, 1, true, false },
  508. { OPTION_NO_SECONDARY, ALIAS_NO_SECONDARY, NULL, use_no_secondary, 1, false, false },
  509. { option_no_sort_check, NULL, NULL, no_sort_usage, 1, false, false },
  510. { option_unsorted, NULL, NULL, unsorted_usage, 1, false, false },
  511. { option_sorted, NULL, NULL, sorted_usage, 1, false, false },
  512. { option_no_verify, NULL, NULL, no_verify_usage, 1, false, false },
  513. { option_only_verify, NULL, NULL, only_verify_usage, 1, false, false },
  514. { option_use_qual, NULL, NULL, use_QUAL_usage, 1, false, false },
  515. { option_ref_config, NULL, NULL, use_ref_config, 1, false, false },
  516. { option_ref_filter, NULL, NULL, use_ref_filter, 1, true, false },
  517. { option_edit_aligned_qual, NULL, NULL, use_edit_aligned_qual, 1, true, false },
  518. { option_keep_mismatch_qual, NULL, NULL, use_keep_mismatch_qual, 1, false, false },
  519. { OPTION_MAX_REC_COUNT, NULL, NULL, mrc_usage, 1, true, false },
  520. { OPTION_MAX_ERR_COUNT, ALIAS_MAX_ERR_COUNT, NULL, mec_usage, 1, true, false },
  521. { OPTION_REF_FILE, ALIAS_REF_FILE, NULL, use_ref_file, 0, true, false },
  522. { OPTION_TI, NULL, NULL, use_TI, 1, false, false },
  523. { OPTION_MAX_WARN_DUP_FLAG, NULL, NULL, use_max_dup_warnings, 1, true, false },
  524. { OPTION_ACCEPT_HARD_CLIP, NULL, NULL, use_accept_hard_clip, 1, false, false },
  525. { OPTION_ALLOW_MULTI_MAP, NULL, NULL, use_allow_multi_map, 1, false, false },
  526. { OPTION_ALLOW_SECONDARY, NULL, NULL, use_allow_secondary, 1, false, false },
  527. { OPTION_DEFER_SECONDARY, NULL, NULL, use_defer_secondary, 1, false, false },
  528. { OPTION_SPOT_BATCH_SIZE, NULL, NULL, spot_batch_size, 1, true, false },
  529. { OPTION_THREADS, NULL, NULL, number_of_threads, 1, true, false },
  530. { OPTION_EXTRA_LOGGING, NULL, NULL, is_extra_logging, 1, false, false },
  531. { OPTION_MIN_BATCH_SIZE, NULL, NULL, min_batch_size_usage, 1, true, false },
  532. { OPTION_TELEMETRY, NULL, NULL, telemetry_usage, 1, true, false },
  533. };
  535. const char* OptHelpParam[] =
  536. {
  537. /* order here is same as in OptDef array above!!! */
  538. "path", /* input */
  539. "path", /* output */
  540. "path-to-file", /* config */
  541. "path-to-file", /* header */
  542. "path", /* tmpfs */
  543. "path-to-file", /* unaligned */
  544. NULL, /* accept dups */
  545. NULL, /* accept no-match */
  546. "path-to-file", /* no-match log */
  547. "level", /* quality compression */
  548. "phred-score", /* min. mapq */
  549. "mbytes", /* cache size */
  550. NULL, /* no colorspace */
  551. "count", /* min. match count */
  552. NULL, /* no secondary */
  553. NULL, /* no_sort */
  554. NULL, /* unsorted */
  555. NULL, /* sorted */
  556. NULL, /* no verify ref's */
  557. NULL, /* quit after verify ref's */
  558. NULL, /* force QUAL */
  559. NULL, /* ref's from config */
  560. "name", /* only this ref */
  561. "new-value", /* value for aligned qualities */
  562. NULL, /* no quantize mismatch qualities */
  563. "number", /* max. record count to process */
  564. "number", /* max. error count */
  565. "path-to-file", /* reference fasta file */
  566. NULL, /* use XT->TI */
  567. "count", /* max. duplicate warning count */
  568. NULL, /* allow hard clipping */
  569. NULL, /* allow multimapping */
  570. NULL, /* allow secondary */
  571. NULL, /* defer secondary */
  572. NULL, /* search batch size */
  573. NULL, /* threads */
  574. NULL, /* extra logging */
  575. "count", /* min cache size */
  576. "file-name" /* telemetry file name */
  577. };
  579. rc_t UsageSummary (char const * progname)
  580. {
  581. return KOutMsg (
  582. "Usage:\n"
  583. "\t%s [options] <bam-file>\n"
  584. "\n"
  585. "Summary:\n"
  586. "\tLoad a BAM formatted data file\n"
  587. "\n"
  588. "Example:\n"
  589. "\t%s -o /tmp/SRZ123456 -k analysis.bam.cfg 123456.bam\n"
  590. "\n"
  591. ,progname, progname);
  592. }
  594. char const UsageDefaultName[] = "bam-load";
  595. static const unsigned DEFAULT_BATCH_SIZE = 240e6;
  596. static const unsigned DEFAULT_MIN_SPOT_ASSEMPLY_BATCH_SIZE = 10e6;
  598. rc_t CC Usage (const Args * args)
  599. {
  600. rc_t rc;
  601. size_t i;
  602. const char * progname = UsageDefaultName;
  603. const char * fullpath = UsageDefaultName;
  604. const size_t argsQty = sizeof(Options) / sizeof(Options[0]);
  606. if (args == NULL)
  607. rc = RC (rcApp, rcArgv, rcAccessing, rcSelf, rcNull);
  608. else
  609. rc = ArgsProgram (args, &fullpath, &progname);
  610. if (rc)
  611. progname = fullpath = UsageDefaultName;
  613. UsageSummary (progname);
  615. for(i = 0; i < argsQty; i++ ) {
  616. if( Options[i].required && Options[i].help[0] != NULL ) {
  617. HelpOptionLine(Options[i].aliases, Options[i].name, OptHelpParam[i], Options[i].help);
  618. }
  619. }
  620. OUTMSG(("\nOptions:\n"));
  621. for(i = 0; i < argsQty; i++ ) {
  622. if( !Options[i].required && Options[i].help[0] != NULL ) {
  623. HelpOptionLine(Options[i].aliases, Options[i].name, OptHelpParam[i], Options[i].help);
  624. }
  625. }
  626. XMLLogger_Usage();
  627. OUTMSG(("\n"));
  628. HelpOptionsStandard ();
  629. HelpVersion (fullpath, KAppVersion());
  630. return rc;
  631. }
  633. /* MARK: Definitions and Globals */
  635. #define SCHEMAFILE "align/align.vschema"
  637. Globals G;
  639. #ifdef _WIN32
  640. #include <process.h>
  641. #else
  642. #include <unistd.h>
  643. #endif
  644. static void set_pid(void)
  645. {
  646. G.pid = getpid();
  647. }
  649. static rc_t PathWithBasePath(char rslt[], size_t sz, char const path[], char const base[])
  650. {
  651. size_t const plen = strlen(path);
  652. bool const hasBase = base && base[0];
  653. bool const isBareName = strchr(path, '/') == NULL;
  655. if (isBareName && hasBase) {
  656. if (string_printf(rslt, sz, NULL, "%s/%s", base, path) == 0)
  657. return 0;
  658. }
  659. else if (plen < sz) {
  660. strncpy(rslt, path, sz);
  661. return 0;
  662. }
  663. {
  664. rc_t const rc = RC(rcApp, rcArgv, rcAccessing, rcBuffer, rcInsufficient);
  665. (void)LOGERR(klogErr, rc, "The path to the file is too long");
  666. return rc;
  667. }
  668. }
  670. static rc_t OpenFile(KFile const **kf, char const path[], char const base[])
  671. {
  672. char fname[4096];
  673. rc_t rc = PathWithBasePath(fname, sizeof(fname), path, base);
  675. if (rc == 0) {
  676. KDirectory *dir;
  678. rc = KDirectoryNativeDir(&dir);
  679. if (rc == 0) {
  680. rc = KDirectoryOpenFileRead(dir, kf, "%s", fname);
  681. KDirectoryRelease(dir);
  682. }
  683. }
  684. return rc;
  685. }
  687. static rc_t LoadHeader(char const **rslt, char const path[], char const base[])
  688. {
  689. KFile const *kf;
  690. rc_t rc = OpenFile(&kf, path, base);
  692. *rslt = NULL;
  693. if (rc == 0) {
  694. uint64_t fsize;
  695. rc = KFileSize(kf, &fsize);
  696. if (rc == 0) {
  697. char *fdata = (char*)malloc(fsize+1);
  699. if (fdata) {
  700. size_t nread;
  701. rc = KFileRead(kf, 0, fdata, fsize, &nread);
  702. if (rc == 0) {
  703. if (nread) {
  704. fdata[nread] = '\0';
  705. *rslt = fdata;
  706. }
  707. else {
  708. free(fdata);
  709. rc = RC(rcApp, rcArgv, rcAccessing, rcFile, rcEmpty);
  710. (void)PLOGERR(klogErr, (klogErr, rc, "File '$(file)' is empty", "file=%s", path));
  711. }
  712. }
  713. else {
  714. (void)PLOGERR(klogErr, (klogErr, rc, "Failed to read file '$(file)'", "file=%s", path));
  715. }
  716. }
  717. else {
  718. rc = RC(rcApp, rcArgv, rcAccessing, rcMemory, rcExhausted);
  719. (void)PLOGERR(klogErr, (klogErr, rc, "Failed to read file '$(file)'", "file=%s", path));
  720. }
  721. }
  722. KFileRelease(kf);
  723. }
  724. else {
  725. (void)PLOGERR(klogErr, (klogErr, rc, "Failed to open file '$(file)'", "file=%s", path));
  726. }
  727. return rc;
  728. }
  730. static rc_t main_help_vers(int argc, char * argv[])
  731. {
  732. Args *args = NULL;
  733. rc_t const rc = ArgsMakeAndHandle (&args, argc, argv, 2, Options,
  734. sizeof Options / sizeof (OptDef), XMLLogger_Args, XMLLogger_ArgsQty);
  735. ArgsWhack(args);
  736. return rc;
  737. }
  739. static rc_t getArgValue(Args *const args, char const *name, int index, char const **result)
  740. {
  741. void const *value;
  742. rc_t const rc = ArgsOptionValue(args, name, index, &value);
  743. if (rc) return rc;
  744. free((void *)*result);
  745. *result = string_dup_measure((const char*)value, NULL);
  746. assert(*result);
  747. return 0;
  748. }
  750. static bool getFlag(Args *const args, char const *name, rc_t *rc)
  751. {
  752. uint32_t count = 0;
  753. *rc = ArgsOptionCount(args, name, &count);
  754. return *rc == 0 ? (count > 0) : false;
  755. }
  757. #define SET_FLAG(FLAG, OPTNAME) FLAG |= getFlag(args, OPTNAME, &rc); if (rc) break
  758. static rc_t main_1(int argc, char *argv[], bool const continuing, unsigned const load)
  759. {
  760. Args *args;
  761. rc_t rc;
  762. unsigned n_aligned = 0;
  763. unsigned n_unalgnd = 0;
  764. char *aligned[256];
  765. char *unalgnd[256];
  766. char *name_buffer = NULL;
  767. unsigned next_name = 0;
  768. unsigned nbsz = 0;
  769. char const *value;
  770. char *dummy;
  772. rc = ArgsMakeAndHandle (&args, argc, argv, 1, Options, sizeof(Options)/sizeof(Options[0]));
  773. while (rc == 0) {
  774. uint32_t pcount;
  776. SET_FLAG(G.onlyVerifyReferences, option_only_verify);
  777. SET_FLAG(G.noVerifyReferences, option_no_verify);
  778. SET_FLAG(G.useQUAL, option_use_qual);
  779. SET_FLAG(G.limit2config, option_ref_config);
  780. SET_FLAG(G.noSortOrderCheck, option_no_sort_check);
  781. SET_FLAG(G.expectUnsorted, option_unsorted);
  782. SET_FLAG(G.requireSorted, option_sorted);
  783. SET_FLAG(G.acceptBadDups, OPTION_ACCEPT_DUP);
  784. SET_FLAG(G.acceptNoMatch, OPTION_ACCEPT_NOMATCH);
  785. SET_FLAG(G.keepMismatchQual, option_keep_mismatch_qual);
  786. SET_FLAG(G.noColorSpace, OPTION_NO_CS);
  787. SET_FLAG(G.noSecondary, OPTION_NO_SECONDARY);
  788. SET_FLAG(G.hasTI, OPTION_TI);
  789. SET_FLAG(G.acceptHardClip, OPTION_ACCEPT_HARD_CLIP);
  790. SET_FLAG(G.allowMultiMapping, OPTION_ALLOW_MULTI_MAP);
  791. SET_FLAG(G.assembleWithSecondary, OPTION_ALLOW_SECONDARY);
  792. SET_FLAG(G.deferSecondary, OPTION_DEFER_SECONDARY);
  793. SET_FLAG(G.hasExtraLogging, OPTION_EXTRA_LOGGING);
  795. rc = ArgsOptionCount(args, OPTION_REF_FILE, &pcount);
  796. if (rc)
  797. break;
  798. if (pcount && G.refFiles) {
  799. int i;
  801. for (i = 0; G.refFiles[i]; ++i)
  802. free((void *)G.refFiles[i]);
  803. free((void *)G.refFiles);
  804. }
  805. G.refFiles = (const char**)calloc(pcount + 1, sizeof(*(G.refFiles)));
  806. if (!G.refFiles) {
  807. rc = RC(rcApp, rcArgv, rcAccessing, rcMemory, rcExhausted);
  808. break;
  809. }
  810. while(pcount-- > 0) {
  811. rc = getArgValue(args, OPTION_REF_FILE, pcount, &G.refFiles[pcount]);
  812. if (rc)
  813. break;
  814. }
  816. rc = ArgsOptionCount (args, OPTION_TMPFS, &pcount);
  817. if (rc)
  818. break;
  819. if (pcount == 1)
  820. {
  821. rc = getArgValue(args, OPTION_TMPFS, 0, &G.tmpfs);
  822. if (rc)
  823. break;
  824. }
  825. else if (pcount > 1)
  826. {
  827. rc = RC(rcApp, rcArgv, rcAccessing, rcParam, rcExcessive);
  828. OUTMSG (("Single parameter required\n"));
  829. MiniUsage (args);
  830. break;
  831. }
  833. rc = ArgsOptionCount (args, OPTION_INPUT, &pcount);
  834. if (rc)
  835. break;
  836. if (pcount == 1)
  837. {
  838. rc = getArgValue(args, OPTION_INPUT, 0, &G.inpath);
  839. if (rc)
  840. break;
  841. }
  842. else if (pcount > 1)
  843. {
  844. rc = RC(rcApp, rcArgv, rcAccessing, rcParam, rcExcessive);
  845. OUTMSG (("Single input parameter required\n"));
  846. MiniUsage (args);
  847. break;
  848. }
  850. rc = ArgsOptionCount (args, option_ref_filter, &pcount);
  851. if (rc)
  852. break;
  853. if (pcount == 1)
  854. {
  855. rc = getArgValue(args, option_ref_filter, 0, &G.refFilter);
  856. if (rc)
  857. break;
  858. }
  859. else if (pcount > 1)
  860. {
  861. rc = RC(rcApp, rcArgv, rcAccessing, rcParam, rcExcessive);
  862. OUTMSG (("Single parameter required\n"));
  863. MiniUsage (args);
  864. break;
  865. }
  867. rc = ArgsOptionCount (args, OPTION_CONFIG, &pcount);
  868. if (rc)
  869. break;
  870. if (pcount == 1)
  871. {
  872. rc = getArgValue(args, OPTION_CONFIG, 0, &G.refXRefPath);
  873. if (rc)
  874. break;
  875. }
  876. else if (pcount > 1)
  877. {
  878. rc = RC(rcApp, rcArgv, rcAccessing, rcParam, rcExcessive);
  879. OUTMSG (("Single input parameter required\n"));
  880. MiniUsage (args);
  881. break;
  882. }
  884. rc = ArgsOptionCount (args, OPTION_OUTPUT, &pcount);
  885. if (rc)
  886. break;
  887. if (pcount == 1)
  888. {
  889. rc = getArgValue(args, OPTION_OUTPUT, 0, &G.outpath);
  890. if (rc)
  891. break;
  892. if (load == 0) {
  893. G.firstOut = string_dup_measure(G.outpath, NULL);
  894. }
  895. value = strrchr(G.outpath, '/');
  896. G.outname = value ? (value + 1) : G.outpath;
  897. }
  898. else if (pcount > 1)
  899. {
  900. rc = RC(rcApp, rcArgv, rcAccessing, rcParam, rcExcessive);
  901. OUTMSG (("Single output parameter required\n"));
  902. MiniUsage (args);
  903. break;
  904. }
  905. else if (!G.onlyVerifyReferences) {
  906. rc = RC(rcApp, rcArgv, rcAccessing, rcParam, rcInsufficient);
  907. OUTMSG (("Output parameter required\n"));
  908. MiniUsage (args);
  909. break;
  910. }
  912. rc = ArgsOptionCount (args, OPTION_MINMAPQ, &pcount);
  913. if (rc)
  914. break;
  915. if (pcount == 1)
  916. {
  917. rc = ArgsOptionValue(args, OPTION_MINMAPQ, 0, (const void **)&value);
  918. if (rc)
  919. break;
  920. G.minMapQual = strtoul(value, &dummy, 0);
  921. }
  923. rc = ArgsOptionCount (args, OPTION_QCOMP, &pcount);
  924. if (rc)
  925. break;
  926. if (pcount == 1)
  927. {
  928. rc = getArgValue(args, OPTION_QCOMP, 0, &G.QualQuantizer);
  929. if (rc)
  930. break;
  931. }
  933. rc = ArgsOptionCount (args, option_edit_aligned_qual, &pcount);
  934. if (rc)
  935. break;
  936. if (pcount == 1)
  937. {
  938. rc = ArgsOptionValue (args, option_edit_aligned_qual, 0, (const void **)&value);
  939. if (rc)
  940. break;
  941. G.alignedQualValue = strtoul(value, &dummy, 0);
  942. if (G.alignedQualValue == 0) {
  943. rc = RC(rcApp, rcArgv, rcAccessing, rcParam, rcIncorrect);
  944. OUTMSG (("edit-aligned-qual: bad value\n"));
  945. MiniUsage (args);
  946. break;
  947. }
  948. G.editAlignedQual = true;
  949. }
  951. rc = ArgsOptionCount (args, OPTION_CACHE_SIZE, &pcount);
  952. if (rc)
  953. break;
  954. if (pcount == 1)
  955. {
  956. rc = ArgsOptionValue (args, OPTION_CACHE_SIZE, 0, (const void **)&value);
  957. if (rc)
  958. break;
  959. G.cache_size = strtoul(value, &dummy, 0) * 1024UL * 1024UL;
  960. if (G.cache_size == 0) {
  961. rc = RC(rcApp, rcArgv, rcAccessing, rcParam, rcIncorrect);
  962. OUTMSG (("cache-size: bad value\n"));
  963. MiniUsage (args);
  964. break;
  965. }
  966. }
  968. rc = ArgsOptionCount (args, OPTION_MAX_WARN_DUP_FLAG, &pcount);
  969. if (rc)
  970. break;
  971. if (pcount == 1)
  972. {
  973. rc = ArgsOptionValue (args, OPTION_MAX_WARN_DUP_FLAG, 0, (const void **)&value);
  974. if (rc)
  975. break;
  976. G.maxWarnCount_DupConflict = strtoul(value, &dummy, 0);
  977. }
  979. rc = ArgsOptionCount (args, OPTION_MAX_REC_COUNT, &pcount);
  980. if (rc)
  981. break;
  982. if (pcount == 1)
  983. {
  984. rc = ArgsOptionValue (args, OPTION_MAX_REC_COUNT, 0, (const void **)&value);
  985. if (rc)
  986. break;
  987. G.maxAlignCount = strtoul(value, &dummy, 0);
  988. }
  990. rc = ArgsOptionCount (args, OPTION_MAX_ERR_COUNT, &pcount);
  991. if (rc)
  992. break;
  993. if (pcount == 1)
  994. {
  995. rc = ArgsOptionValue (args, OPTION_MAX_ERR_COUNT, 0, (const void **)&value);
  996. if (rc)
  997. break;
  998. G.maxErrCount = strtoul(value, &dummy, 0);
  999. }
  1001. rc = ArgsOptionCount (args, OPTION_MIN_MATCH, &pcount);
  1002. if (rc)
  1003. break;
  1004. if (pcount == 1)
  1005. {
  1006. rc = ArgsOptionValue (args, OPTION_MIN_MATCH, 0, (const void **)&value);
  1007. if (rc)
  1008. break;
  1009. G.minMatchCount = strtoul(value, &dummy, 0);
  1010. }
  1012. rc = ArgsOptionCount (args, OPTION_NOMATCH_LOG, &pcount);
  1013. if (rc)
  1014. break;
  1015. if (pcount == 1)
  1016. {
  1017. KDirectory *dir;
  1019. rc = ArgsOptionValue (args, OPTION_NOMATCH_LOG, 0, (const void **)&value);
  1020. if (rc) break;
  1021. rc = KDirectoryNativeDir(&dir);
  1022. if (rc) break;
  1023. rc = KDirectoryCreateFile(dir, &G.noMatchLog, 0, 0664, kcmInit, "%s", value);
  1024. KDirectoryRelease(dir);
  1025. if (rc) break;
  1026. }
  1028. rc = ArgsOptionCount (args, OPTION_HEADER, &pcount);
  1029. if (rc)
  1030. break;
  1031. if (pcount == 1) {
  1032. rc = ArgsOptionValue (args, OPTION_HEADER, 0, (const void **)&value);
  1033. if (rc) break;
  1034. free((void *)G.headerText);
  1035. rc = LoadHeader(&G.headerText, value, G.inpath);
  1036. if (rc) break;
  1037. }
  1039. rc = ArgsParamCount (args, &pcount);
  1040. if (rc) break;
  1041. if (pcount == 0)
  1042. {
  1043. rc = RC(rcApp, rcArgv, rcAccessing, rcParam, rcInsufficient);
  1044. MiniUsage (args);
  1045. break;
  1046. }
  1047. else if (pcount > sizeof(aligned)/sizeof(aligned[0])) {
  1048. rc = RC(rcApp, rcArgv, rcAccessing, rcParam, rcExcessive);
  1049. (void)PLOGERR(klogErr, (klogErr, rc, "$(count) input files is too many, $(max) is the limit",
  1050. "count=%u,max=%u", (unsigned)pcount, (unsigned)(sizeof(aligned)/sizeof(aligned[0]))));
  1051. break;
  1052. }
  1053. else {
  1054. unsigned need = G.inpath ? (strlen(G.inpath) + 1) * pcount : 0;
  1055. unsigned i;
  1057. for (i = 0; i < pcount; ++i) {
  1058. rc = ArgsParamValue(args, i, (const void **)&value);
  1059. if (rc) break;
  1060. need += strlen(value) + 1;
  1061. }
  1062. nbsz = need;
  1063. }
  1065. rc = ArgsOptionCount (args, OPTION_UNALIGNED, &pcount);
  1066. if (rc)
  1067. break;
  1068. if (pcount > 0)
  1069. {
  1070. unsigned need = G.inpath ? (strlen(G.inpath) + 1) * pcount : 0;
  1071. unsigned i;
  1073. for (i = 0; i < pcount; ++i) {
  1074. rc = ArgsOptionValue(args, OPTION_UNALIGNED, i, (const void **)&value);
  1075. if (rc) break;
  1076. need += strlen(value) + 1;
  1077. }
  1078. if (rc) break;
  1079. nbsz += need;
  1080. }
  1082. name_buffer = (char*)malloc(nbsz);
  1083. if (name_buffer == NULL) {
  1084. rc = RC(rcApp, rcArgv, rcAccessing, rcMemory, rcExhausted);
  1085. break;
  1086. }
  1088. rc = ArgsOptionCount (args, OPTION_UNALIGNED, &pcount);
  1089. if (rc == 0) {
  1090. unsigned i;
  1092. for (i = 0; i < pcount; ++i) {
  1093. rc = ArgsOptionValue(args, OPTION_UNALIGNED, i, (const void **)&value);
  1094. if (rc) break;
  1096. unalgnd[n_unalgnd++] = name_buffer + next_name;
  1097. rc = PathWithBasePath(name_buffer + next_name, nbsz - next_name, value, G.inpath);
  1098. if (rc) break;
  1099. next_name += strlen(name_buffer + next_name) + 1;
  1100. }
  1101. if (rc) break;
  1102. }
  1103. else
  1104. break;
  1106. rc = ArgsParamCount (args, &pcount);
  1107. if (rc == 0) {
  1108. unsigned i;
  1110. for (i = 0; i < pcount; ++i) {
  1111. rc = ArgsParamValue(args, i, (const void **)&value);
  1112. if (rc) break;
  1114. aligned[n_aligned++] = name_buffer + next_name;
  1115. rc = PathWithBasePath(name_buffer + next_name, nbsz - next_name, value, G.inpath);
  1116. if (rc) break;
  1117. next_name += strlen(name_buffer + next_name) + 1;
  1118. }
  1119. }
  1120. else
  1121. break;
  1123. rc = ArgsOptionCount (args, OPTION_SPOT_BATCH_SIZE, &pcount);
  1124. if (rc)
  1125. break;
  1126. if (pcount == 1)
  1127. {
  1128. rc = ArgsOptionValue (args, OPTION_SPOT_BATCH_SIZE, 0, (const void **)&value);
  1129. if (rc)
  1130. break;
  1131. G.searchBatchSize = strtoul(value, &dummy, 0);
  1132. if (G.searchBatchSize == 0)
  1133. G.searchBatchSize = DEFAULT_BATCH_SIZE;
  1135. }
  1137. rc = ArgsOptionCount (args, OPTION_THREADS, &pcount);
  1138. if (rc)
  1139. break;
  1140. if (pcount == 1)
  1141. {
  1142. rc = ArgsOptionValue (args, OPTION_THREADS, 0, (const void **)&value);
  1143. if (rc)
  1144. break;
  1146. char* p;
  1147. G.numThreads = strtoul(value, &p, 0);
  1148. if ( * p != 0 || ( G.numThreads < 3 && G.numThreads != 0 ) )
  1149. {
  1150. rc = RC(rcApp, rcArgv, rcAccessing, rcParam, rcIncorrect);
  1151. OUTMSG (("threads: bad value (must be an integer >=3, or 0)\n"));
  1152. MiniUsage (args);
  1153. break;
  1154. }
  1155. if (G.numThreads == 0)
  1156. G.numThreads = 8;
  1157. }
  1159. rc = ArgsOptionCount (args, OPTION_MIN_BATCH_SIZE, &pcount);
  1160. if (rc)
  1161. break;
  1162. if (pcount == 1)
  1163. {
  1164. rc = ArgsOptionValue (args, OPTION_MIN_BATCH_SIZE, 0, (const void **)&value);
  1165. if (rc)
  1166. break;
  1167. G.minBatchSize = strtoul(value, &dummy, 0);
  1168. if (G.minBatchSize == 0) {
  1169. rc = RC(rcApp, rcArgv, rcAccessing, rcParam, rcIncorrect);
  1170. OUTMSG (("min-batch-size: bad value\n"));
  1171. MiniUsage (args);
  1172. break;
  1173. }
  1174. }
  1175. G.telemetryPath = nullptr;
  1176. rc = ArgsOptionCount (args, OPTION_TELEMETRY, &pcount);
  1177. if (rc)
  1178. break;
  1179. if (pcount == 1)
  1180. {
  1181. rc = getArgValue(args, OPTION_TELEMETRY, 0, &G.telemetryPath);
  1182. if (rc)
  1183. break;
  1184. }
  1185. else if (pcount > 1)
  1186. {
  1187. rc = RC(rcApp, rcArgv, rcAccessing, rcParam, rcExcessive);
  1188. OUTMSG (("Single input parameter required\n"));
  1189. MiniUsage (args);
  1190. break;
  1191. }
  1194. rc = run(argv[0], n_aligned, (char const **)aligned, n_unalgnd, (char const **)unalgnd, continuing);
  1195. break;
  1196. }
  1197. free(name_buffer);
  1199. if (rc) {
  1200. (void)PLOGERR(klogErr, (klogErr, rc, "load failed",
  1201. "severity=total,status=failure,accession=%s,errors=%u", G.outname, G.errCount));
  1202. } else {
  1203. (void)PLOGMSG(klogInfo, (klogInfo, "loaded",
  1204. "severity=total,status=success,accession=%s,errors=%u", G.outname, G.errCount));
  1205. }
  1206. ArgsWhack(args);
  1207. return rc;
  1208. }
  1209. #undef SET_FLAG
  1211. static void cleanupGlobal(void)
  1212. {
  1213. if (G.refFiles) {
  1214. int i;
  1216. for (i = 0; G.refFiles[i]; ++i)
  1217. free((void *)G.refFiles[i]);
  1218. free((void *)G.refFiles);
  1219. }
  1220. free((void *)G.tmpfs);
  1221. free((void *)G.inpath);
  1222. free((void *)G.refFilter);
  1223. free((void *)G.refXRefPath);
  1224. free((void *)G.outpath);
  1225. free((void *)G.firstOut);
  1226. free((void *)G.headerText);
  1227. free((void *)G.QualQuantizer);
  1228. free((void *)G.schemaPath);
  1229. free((void *)G.telemetryPath);
  1230. }
  1232. static int find_arg(char const *const *const query, int const first, int const argc, char **const argv)
  1233. {
  1234. int i;
  1236. for (i = first; i < argc; ++i) {
  1237. int j;
  1239. for (j = 0; query[j] != NULL; ++j) {
  1240. if (strcmp(argv[i], query[j]) == 0)
  1241. return i;
  1242. }
  1243. }
  1244. return 0;
  1245. }
  1247. static bool has_arg(char const *const *const query, int const argc, char **const argv)
  1248. {
  1249. return find_arg(query, 1, argc, argv) > 0;
  1250. }
  1252. static const char *logger_options[] = { "--xml-log-fd", "--xml-log", "-z" };
  1253. static XMLLogger const *make_logger(int *argc, char *argv[])
  1254. {
  1255. XMLLogger const *rslt = NULL;
  1256. char *argf[4];
  1257. int i;
  1259. argf[0] = argv[0];
  1260. argf[1] = NULL;
  1261. argf[2] = NULL;
  1262. argf[3] = NULL;
  1264. for (i = 1; i < *argc; ++i) {
  1265. int remove = 0;
  1267. if (strcmp(argv[i], logger_options[2]) == 0) {
  1268. argf[1] = argv[i];
  1269. argf[2] = argv[i + 1];
  1270. remove = 2;
  1271. }
  1272. else {
  1273. int j;
  1275. for (j = 0; j < 2; ++j) {
  1276. if (strstr(argv[i], logger_options[j]) == argv[i]) {
  1277. int const n = strlen(logger_options[j]);
  1279. if (argv[i][n] == '\0') {
  1280. argf[1] = argv[i];
  1281. argf[2] = argv[i + 1];
  1282. remove = 2;
  1283. }
  1284. else if (argv[i][n] == '=') {
  1285. argv[i][n] = '\0';
  1286. argf[1] = argv[i];
  1287. argf[2] = argv[i] + n + 1;
  1288. remove = 1;
  1289. }
  1290. break;
  1291. }
  1292. }
  1293. }
  1294. if (argf[1] != NULL) {
  1295. Args *args = NULL;
  1297. ArgsMakeAndHandle(&args, 3, argf, 1, XMLLogger_Args, XMLLogger_ArgsQty);
  1298. if (args) {
  1299. XMLLogger_Make(&rslt, NULL, args);
  1300. ArgsWhack(args);
  1301. }
  1302. }
  1303. if (remove) {
  1304. *argc -= remove;
  1305. memmove(argv + i, argv + i + remove, (*argc + 1) * sizeof(argv[0]));
  1306. break;
  1307. }
  1308. }
  1309. return rslt;
  1310. }
  1312. MAIN_DECL( argc, argv )
  1313. {
  1314. if ( VdbInitialize( argc, argv, 0 ) )
  1315. return VDB_INIT_FAILED;
  1317. static const char *help[] = { "--help", "-h", "-?", NULL };
  1318. static const char *vers[] = { "--version", "-V", NULL };
  1320. SetUsage( Usage );
  1321. SetUsageSummary( UsageSummary );
  1323. bool const has_help = has_arg(help, argc, argv);
  1324. bool const has_vers = has_arg(vers, argc, argv);
  1325. XMLLogger const *logger = NULL;
  1326. int argfirst = 0;
  1327. int arglast = 0;
  1328. rc_t rc = 0;
  1329. unsigned load = 0;
  1331. assert(sizeof Options / sizeof Options[0] ==
  1332. sizeof OptHelpParam / sizeof OptHelpParam[0]
  1333. && "Options & OptHelpParam have to match");
  1335. if (has_help) {
  1336. argc = 2;
  1337. argv[1] = (char*)"--help";
  1338. return main_help_vers(argc, argv);
  1339. }
  1340. if (has_vers) {
  1341. argc = 2;
  1342. argv[1] = (char*)"--version";
  1343. return main_help_vers(argc, argv);
  1344. }
  1346. logger = make_logger(&argc, argv);
  1348. memset(&G, 0, sizeof(G));
  1349. G.mode = mode_Archive;
  1350. G.globalMode = mode_Archive;
  1351. G.maxSeqLen = TableWriterRefSeq_MAX_SEQ_LEN;
  1352. G.schemaPath = string_dup_measure(SCHEMAFILE, NULL);
  1353. G.omit_aligned_reads = true;
  1354. G.omit_reference_reads = true;
  1355. G.minMapQual = 0; /* accept all */
  1356. G.tmpfs = string_dup_measure("/tmp", NULL);
  1357. G.cache_size = ((size_t)16) << 30;
  1358. G.maxErrCount = 1000;
  1359. G.minMatchCount = 10;
  1360. G.searchBatchSize = DEFAULT_BATCH_SIZE;
  1361. G.numThreads = 8;
  1362. G.minBatchSize = DEFAULT_MIN_SPOT_ASSEMPLY_BATCH_SIZE;
  1363. if (char* env = getenv("LOADER_MEM_LIMIT_GB")) {
  1364. G.LOADER_MEM_LIMIT_GB = atoi(env);
  1365. (void)PLOGMSG(klogInfo, (klogInfo, "LOADER_MEM_LIMIT_GB=$(cnt)", "cnt=%u", G.LOADER_MEM_LIMIT_GB));
  1366. } else {
  1367. G.LOADER_MEM_LIMIT_GB = 0;
  1368. }
  1370. set_pid();
  1372. for (arglast = 1; arglast < argc; ++arglast) {
  1373. if (strcmp(argv[arglast], "--remap") == 0) {
  1374. argv[arglast] = argv[0];
  1375. G.globalMode = mode_Remap;
  1376. rc = main_1(arglast - argfirst, argv + argfirst, true, load);
  1377. if (rc)
  1378. break;
  1379. G.mode = mode_Remap;
  1380. argfirst = arglast;
  1381. ++load;
  1382. }
  1383. }
  1384. rc = main_1(arglast - argfirst, argv + argfirst, false, load);
  1385. XMLLogger_Release(logger);
  1386. cleanupGlobal();
  1387. return VdbTerminate( rc );
  1388. }

bam-loader.c at commit 434ae78, under other · at the source

Overview

Authors: Jihoon Park1, Jin-Gwan Jeon2, Youbin Kang3, Kyu-Man Han1, Daun Shin4, Mi-Ryung Han2,5, Byung-Joo Ham1
ORCID iDs: Byung-Joo Ham
  1. Department of Psychiatry, Korea University Anam Hospital, Korea University College of Medicine, Seoul, Republic of Korea
  2. Division of Life Sciences, College of Life Sciences and Bioengineering, Incheon National University, Incheon, Republic of Korea
  3. Department of Biomedical Sciences, Korea University College of Medicine, Seoul, Republic of Korea
  4. Department of Psychiatry, Asan Medical Center, Seoul, Republic of Korea
  5. Institute for New Drug Development, College of Life Science and Bioengineering, Incheon National University, Incheon, Republic of Korea
Institutions: Korea University Anam Hospital (South Korea); Incheon National University (South Korea); Korea University (South Korea); Asan Medical Center (South Korea)
Journal: Frontiers in behavioral neuroscience, volume 20, article 1878769
Dates: received 12 May 2026; accepted 8 July 2026; published online 29 July 2026
Type: Research article · Language: English
License: CC BY
Identifiers: DOI 10.3389/fnbeh.2026.1878769 · PMID 42591615 · PMCID PMC13462048 · OpenAlex W7171700345
Open access: gold, a free copy (OpenAlex)
Status: code verified
Categories: genetics / omics (modality), structural MRI / diffusion (modality), human (organism), other (organism), depression (population), cellular / molecular (subfield)
Methods: Statistics, Smoothing, state filtering, decompositions, fMRI & imaging
Keywords: ADAMTS18, cross-species genomics, diffusion tensor imaging, Lycaon pictus, major depressive disorder, neuroimaging genetics, white matter connectivity
Topic: Human-Animal Interaction Studies (Genetics, Biochemistry, Genetics and Molecular Biology), according to OpenAlex
Funding: National Research Foundation; Incheon National University; National Research Foundation of Korea (NRF-2022R1A2C2093009, 2022R1A2C2093009); Ministry of Science and ICT, South Korea (NRF-2022R1A2C2093009)
Citations: not cited yet (Europe PMC); 90 references in the paper

Abstract

Background: Major depressive disorder (MDD) is a leading cause of disability; however, its neurogenetic mechanisms remain partially understood. Comparative genomic approaches reveal evolutionarily conserved risk factors, particularly when applied to ecologically valid models. Lycaon pictus is a social carnivore whose affiliative behavior has been shaped by natural selection. Since impaired social and affiliative function are a feature of depression, genes selected for social function in this species may serve as candidates for the social-affective dimension of MDD. Here, a comparative approach was integrated with human neuroimaging–genetic analysis, focusing on white matter phenotypes.

Methods: Whole-genome sequencing data from Lycaon pictus (n = 7) and Canis lupus (n = 36) were analyzed alongside a human cohort of 367 patients with MDD and 161 healthy controls using rare variant association tests. Across analyses, ADAMTS18 emerged as a convergent gene of interest. Whole-exome sequencing and diffusion tensor imaging (DTI) were conducted on 234 patients with MDD and 135 healthy controls. Eleven common SNPs within ADAMTS18 were examined for genotype-by-diagnosis and genotype-by-symptom interactions using tract-based DTI metrics.

Results: SNP rs11643211 showed a nominal genotype × diagnosis interaction on axial diffusivity in the bilateral uncinate fasciculus, with elevated values in A allele carriers with MDD. In symptom-based models, rs1948719 was nominally associated with depression severity in the left cingulum–cingulate gyrus. Although these associations did not survive false discovery rate correction, the nominal effects appeared to cluster within tracts implicated in affective integration and self-referential cognition.

Conclusion: The present study is hypothesis-generating and identifies ADAMTS18 as a gene worth further study in relation to white matter and depression. Cross-species neurogenomics may offer a useful framework for investigating links among social behavior, genetic variation and psychiatric vulnerability. However, given the small sample sizes and the absence of FDR-significant results, these findings should be interpreted as providing an exploratory framework for identifying candidate markers relevant to MDD.

Reproduced under the paper's license (CC BY), from the paper cited above.

Repository

Its files are read in the Code ↔ Paper reader above, with 2 matches between paragraphs and lines of code.

ncbi/sra-tools

License: other
State: the link answers, verified on 27 September 2026
Evidence: files inventoried
Commit: 434ae787c86e32e7faa5e80417a342c365fa03b0, 25 March 2026
Languages: C/C++ (605), C (422), C++ (287), Shell (189), Java (74), Python (69), Perl (40)
Size: 3,759 files, 1,686 scripts
Software Heritage: archived
Found in: the text, “Processing of the sequencing data”
Holds: README, license file, environment (build/docker/Dockerfile, build/docker/Dockerfile.build-alpine, build/docker/Dockerfile.build-alpine-debug, build/docker/Dockerfile.build-amazonlinux, build/docker/Dockerfile.build-ubuntu, build/docker/Dockerfile.build_with_loaders-alpine, build/docker/Dockerfile.delite, ngs/ngs-python/setup.py), tests
Not found: CITATION.cff, continuous integration, documentation
Tools: h5py (1 file)
Availability: 1 check, the latest on 27 September 2026: the link answers
  • 27 September 2026: the link answers
1,652 files
At the source: github.com/ncbi/sra-tools

Tracing map

Proposed by the machine: these links were found in the paper and verified at the source, without human review. The map will receive a Zenodo DOI once one of the paper's authors has validated it with their ORCID.

What the map holds:

  • 1 repository of the authors' code, each at its verified commit, with its license and how the link was found in the paper;
  • 1,650 scripts, each with its path and the digest of its content;
  • 2 matches between paragraphs of the paper and lines of the code (method lexical-v1);
  • neither the text of the paper nor the code itself.

Its JSON (tracing-map.json) is deposited on Zenodo with its DOI once the map is validated.

Data

No dataset and no data link were found in the paper.

Data availability statement

The datasets presented in this study can be found in online repositories. The names of the repositories and accession numbers can be found in the article/Supplementary material. Human genetic and neuroimaging datasets generated and analyzed during the current study are available from the corresponding author upon reasonable request and subject to institutional ethical and privacy restrictions.

Reproduced under the paper's license (CC BY), from the paper cited above.

Versions

The history of this record: each version stored by the harvester or made by a correction of its authors or of the maintainers of its code, and what changed in its facts. The texts of the paper (its abstract, its availability statements) are not part of it; versions that changed only those are not listed.

Version 2, 28 September 2026

  • Funding: added National Research Foundation; Incheon National University; National Research Foundation of Korea: NRF-2022R1A2C2093009, 2022R1A2C2093009; Ministry of Science and ICT, South Korea: NRF-2022R1A2C2093009

Version 1, 27 September 2026: the first record

Recorded: type, language, journal, volume, pages, dates, 7 authors, 7 keywords, 86 references.

Cite

This paper

Park, J., Jeon, J.-G., Kang, Y., Han, K.-M., Shin, D., Han, M.-R., & Ham, B.-J. (2026). &lt;i&gt;ADAMTS18&lt;/i&gt; as a candidate gene linking social stress and depression: a cross-species study in African wild dogs (&lt;i&gt;Lycaon pictus&lt;/i&gt;) and humans. Frontiers in behavioral neuroscience, 20, 1878769. https://doi.org/10.3389/fnbeh.2026.1878769

BibTeX

@article{park2026lt,
author = {Park, Jihoon and Jeon, Jin-Gwan and Kang, Youbin and Han, Kyu-Man and Shin, Daun and Han, Mi-Ryung and Ham, Byung-Joo},
title = {{\&lt;i\&gt;ADAMTS18\&lt;/i\&gt; as a candidate gene linking social stress and depression: a cross-species study in African wild dogs (\&lt;i\&gt;Lycaon pictus\&lt;/i\&gt;) and humans}},
journal = {Frontiers in behavioral neuroscience},
year = {2026},
month = jul,
volume = {20},
pages = {1878769},
publisher = {Frontiers Media SA},
issn = {1662-5153},
doi = {10.3389/fnbeh.2026.1878769},
url = {https://doi.org/10.3389/fnbeh.2026.1878769},
pmid = {42591615},
pmcid = {PMC13462048}
}

RIS

TY - JOUR
AU - Park, Jihoon
AU - Jeon, Jin-Gwan
AU - Kang, Youbin
AU - Han, Kyu-Man
AU - Shin, Daun
AU - Han, Mi-Ryung
AU - Ham, Byung-Joo
TI - &lt;i&gt;ADAMTS18&lt;/i&gt; as a candidate gene linking social stress and depression: a cross-species study in African wild dogs (&lt;i&gt;Lycaon pictus&lt;/i&gt;) and humans
T2 - Frontiers in behavioral neuroscience
J2 - Front Behav Neurosci
PY - 2026
DA - 2026/07/29
VL - 20
SP - 1878769
SN - 1662-5153
PB - Frontiers Media SA
DO - 10.3389/fnbeh.2026.1878769
UR - https://doi.org/10.3389/fnbeh.2026.1878769
LA - en
ER -

CSL-JSON

{
"id": "10.3389/fnbeh.2026.1878769",
"type": "article-journal",
"title": "&lt;i&gt;ADAMTS18&lt;/i&gt; as a candidate gene linking social stress and depression: a cross-species study in African wild dogs (&lt;i&gt;Lycaon pictus&lt;/i&gt;) and humans",
"container-title": "Frontiers in behavioral neuroscience",
"author": [
{
"family": "Park",
"given": "Jihoon"
},
{
"family": "Jeon",
"given": "Jin-Gwan"
},
{
"family": "Kang",
"given": "Youbin"
},
{
"family": "Han",
"given": "Kyu-Man"
},
{
"family": "Shin",
"given": "Daun"
},
{
"family": "Han",
"given": "Mi-Ryung"
},
{
"family": "Ham",
"given": "Byung-Joo"
}
],
"container-title-short": "Front Behav Neurosci",
"volume": "20",
"page": "1878769",
"DOI": "10.3389/fnbeh.2026.1878769",
"PMID": "42591615",
"PMCID": "PMC13462048",
"ISSN": "1662-5153",
"publisher": "Frontiers Media SA",
"URL": "https://doi.org/10.3389/fnbeh.2026.1878769",
"language": "en",
"issued": {
"date-parts": [
[
2026,
7,
29
]
]
}
}

The tracing map gets a citation of its own once an author has validated it and it has a DOI.

Similar papers

The papers with a page that share the most with this one: the tools found in their code, their categories, datasets, cited references and authors, the rarest counting most.

[1] doi:10.1038/s41593-026-02301-4
Deep brain stimulation induces white matter remodeling and functional changes to brain-wide networks.
Journal: Nature neuroscience
In common: depression, 4 references
[2] doi:10.1073/pnas.2609814123 [code]
Genetic architectures of brain-related traits are shaped by strong selective constraints.
Journal: Proceedings of the National Academy of Sciences of the United States of America
In common: genetics / omics, cellular / molecular, 4 references
[3] doi:10.1016/j.isci.2026.116429 [code]
&lt;i&gt;HMGA2&lt;/i&gt; regulates fear and growth: Canine GWAS and functional evidence.
Journal: iScience
In common: other, genetics / omics, 3 references
[4] doi:10.1038/s41467-026-73996-z [code]
Genetic architecture of white matter microstructure captured by unsupervised deep representation learning of fractional anisotropy maps.
Journal: Nature communications
In common: h5py, structural MRI / diffusion, genetics / omics, cellular / molecular, 2 references
[5] doi:10.3389/fpain.2026.1850836 [code]
Diffusion tensor imaging in chronic tension-type headache.
Journal: Frontiers in pain research (Lausanne, Switzerland)
In common: structural MRI / diffusion, 3 references
[6] doi:10.1038/s41398-026-04025-2 [code]
Brain energetic landscapes shape state dysregulation in major depressive disorder: a morphological network controllability perspective.
Journal: Translational psychiatry
In common: h5py, depression, 2 references
[7] doi:10.1017/s0033291726104711
Cell-type and spatiotemporal transcriptional signatures of white matter morphometric similarity network alterations in major depressive disorder.
Journal: Psychological medicine
In common: depression, structural MRI / diffusion, genetics / omics, 1 other category, 2 references
[8] doi:10.1038/s41467-026-75193-4 [code]
Multi-ancestry gene expression models amplify transcriptome-wide association study discovery and validation.
Journal: Nature communications
In common: h5py, genetics / omics, cellular / molecular, 2 references
[9] doi:10.24272/j.issn.2095-8137.2025.270
&lt;i&gt;NOCT&lt;/i&gt;, a potential domestication gene impacting circadian regulation and behavioral adaptation during dog domestication.
Journal: Zoological research
In common: other, cellular / molecular, 2 references
[10] doi:10.1038/s41467-026-71803-3 [code]
Charting the transition from in vitro gliogenesis to the in vivo maturation of human glial progenitor cells transplanted into the hypomyelinated mouse brain.
Journal: Nature communications
In common: h5py, genetics / omics, cellular / molecular, 2 references

Contribute

The authors of this paper can claim it, correct its record and validate its tracing map, and the maintainers of its code (its owner, or a public member of its organization) correct what it says of their repository; anyone signed in can ask for its removal. Every request goes to OSCR's own machine, which answers it; your account page follows them.

Sign in with ORCID to claim this paper as one of its authors, correct its record or validate its tracing map: when the paper's metadata lists your ORCID iD, you are recognized at once. Maintainers of its code: sign in with GitHub, then claim the repository on your account page.

Request its removal

To ask OSCR to remove this record, the copies of its authors' scripts or its tracing map, use the removal request page: signed in, you say who you are, what to remove and why, then review and confirm the request. Published rules decide every request (how).

Discussion, reproductions, activity

Discussion: questions and error reports about this paper and its code, from signed-in readers and its authors. It opens with sign-in.

Reproductions: reports from readers who ran the authors' code: what they reproduced, with which environment, commit and data. It opens with sign-in.

Activity: what happens around this paper: new versions of its record, its map's validation, discussions and reproductions. It opens with sign-in.