From 62fa81367832267c37d7f78dced39d0fc4985079 Mon Sep 17 00:00:00 2001 From: Justin S <3630356+codeandkey@users.noreply.github.com> Date: Wed, 15 May 2019 15:55:10 -0500 Subject: recon: new package at 1.08 (#11408) * recon: new package at 1.08 * recon: add period * recon: use proper decorators, better documentation * recon: fix incorrect os import * recon: add repeatmasker patch as variant --- var/spack/repos/builtin/packages/recon/package.py | 52 ++ .../packages/recon/repeatmasker_recon.patch | 583 +++++++++++++++++++++ 2 files changed, 635 insertions(+) create mode 100644 var/spack/repos/builtin/packages/recon/package.py create mode 100644 var/spack/repos/builtin/packages/recon/repeatmasker_recon.patch (limited to 'var') diff --git a/var/spack/repos/builtin/packages/recon/package.py b/var/spack/repos/builtin/packages/recon/package.py new file mode 100644 index 0000000000..860e2b7ba0 --- /dev/null +++ b/var/spack/repos/builtin/packages/recon/package.py @@ -0,0 +1,52 @@ +# Copyright 2013-2019 Lawrence Livermore National Security, LLC and other +# Spack Project Developers. See the top-level COPYRIGHT file for details. +# +# SPDX-License-Identifier: (Apache-2.0 OR MIT) + +from spack import * +from os import symlink + + +class Recon(MakefilePackage): + """RECON: a package for automated de novo identification of repeat families + from genomic sequences.""" + + homepage = "http://eddylab.org/software/recon/" + url = "http://eddylab.org/software/recon/RECON1.05.tar.gz" + + version('1.05', sha256='4d4f76f439bcffd50380cffc41a80dc15fa4a80f38a04234e24da893ed7c025a') + + variant('repeatmasker', default=False, + description='Use RepeatMasker developer patches (1.08)') + + patch('repeatmasker_recon.patch', when='+repeatmasker') + + build_directory = 'src' + + depends_on('perl', type='run') + + @property + def install_targets(self): + return [ + 'install', + 'BINDIR=%s' % self.prefix.bin + ] + + # edit the recon.pl script with the prefix as mentioned in the README + def edit(self, spec, prefix): + filter_file('$path = ""', '$path = "%s"' % prefix.bin, + 'scripts/recon.pl', string=True) + + # recon's makefile is very basic -- the target directory must + # already exist to properly install + @run_before('install') + def prepare_bin(self): + mkdirp(prefix.bin) + + # finally, install the scripts dir as well + # and link the recon command into bin. + @run_after('install') + def finalize(self): + install_tree('scripts', prefix.scripts) + symlink(join_path(prefix.scripts, 'recon.pl'), + join_path(prefix.bin, 'recon')) diff --git a/var/spack/repos/builtin/packages/recon/repeatmasker_recon.patch b/var/spack/repos/builtin/packages/recon/repeatmasker_recon.patch new file mode 100644 index 0000000000..ed20cc070d --- /dev/null +++ b/var/spack/repos/builtin/packages/recon/repeatmasker_recon.patch @@ -0,0 +1,583 @@ +diff -ruN RECON1.05/00README RECON-1.08/00README +--- RECON1.05/00README 2002-04-08 14:31:59.000000000 -0500 ++++ RECON-1.08/00README 2014-02-05 16:05:18.000000000 -0600 +@@ -1,6 +1,7 @@ + RECON -- finding repeat families from biological sequences +-Version 1.03 (Mar 2002) ++Version 1.08 (Jan 2014) + Copyright (C) 2001 Washington University School of Medicine ++Copyright (C) 2011-2014 Institute for Systems Biology + ------------------------------------------------------------------ + + +@@ -28,8 +29,26 @@ + + What's new? + ++RECON1.08: Wed Feb 5 14:04:25 PST 2014 - Robert Hubley ISB ++ - New checks in eleredef.c for failed memory allocation/file operations. ++ - A buffer overrun bug fix provided by Stephen Ficklin in eledef.c. ++ ++RECON1.07: Wed Jun 8 10:00:55 PDT 2011 - Robert Hubley ISB ++ - Another problem with the eleredef program has appeared a couple ++ of times. A divide by zero error in one of Zhirong's routines. ++ I have applied a workaround to the divide by zero but not a fix ++ to the real problem. The program will now warn the user if ++ the workaround was exercised during a run. ++ ++RECON1.06: Tue May 20 15:19:30 PDT 2008 - Robert Hubley ISB ++ - 64 bit compiler fixes: Previous versions of RECON used the "long" ++ data type under the assumption that was 32bits. This caused the ++ program to crash or lock up during analysis. ++ + Bug fix for RECON1.02 in the eleredef program. + ++ ++ + Programs and input + + The RECON algorithm defines repeat families on the basis of pairwise +@@ -50,7 +69,6 @@ + multiple times and concatenate the result into one MSP file. + + +- + The recon script drives the running of the package. The command + line format is as follows: + +diff -ruN RECON1.05/src/bolts.h RECON-1.08/src/bolts.h +--- RECON1.05/src/bolts.h 2002-01-10 15:19:09.000000000 -0600 ++++ RECON-1.08/src/bolts.h 2014-02-05 16:05:18.000000000 -0600 +@@ -10,5 +10,5 @@ + + + +-long seq_no; ++int32_t seq_no; + char **seq_names; +diff -ruN RECON1.05/src/edgeredef.c RECON-1.08/src/edgeredef.c +--- RECON1.05/src/edgeredef.c 2002-07-19 10:42:03.000000000 -0500 ++++ RECON-1.08/src/edgeredef.c 2014-02-05 16:05:18.000000000 -0600 +@@ -58,6 +58,10 @@ + } + + log_file = fopen("tmp2/log", "w"); ++ if (!log_file) { ++ printf("Can not open log_file. Exiting\n"); ++ exit(1); ++ } + + while (fgets(line, 15, ele_no)) { + ele_ct = atoi(line); +@@ -191,7 +195,7 @@ + } else { + ele_info->stat = 'y'; + ele_cleanup(&ele_info->ele); +- command = (char *) malloc(30*sizeof(char)); ++ command = (char *) malloc(80*sizeof(char)); + sprintf(command, "cp tmp/e%d tmp2/.", ele_info->index); + system(command); + free(command); +diff -ruN RECON1.05/src/eledef.c RECON-1.08/src/eledef.c +--- RECON1.05/src/eledef.c 2002-01-10 15:19:10.000000000 -0600 ++++ RECON-1.08/src/eledef.c 2014-02-05 16:05:18.000000000 -0600 +@@ -385,7 +385,7 @@ + + void img_charge(IPROT_t **shadow, int ct, FILE *input) { + int i=0, pos=0; +- char line[100]; ++ char line[151]; + int scan_flag; + MSP_t msp; + +diff -ruN RECON1.05/src/ele.h RECON-1.08/src/ele.h +--- RECON1.05/src/ele.h 2002-01-10 15:19:09.000000000 -0600 ++++ RECON-1.08/src/ele.h 2014-02-05 16:05:18.000000000 -0600 +@@ -1,7 +1,6 @@ + #include "msps.h" + + +- + #define SIZE_LIMIT 500 + #define TANDEM 5 + +@@ -9,13 +8,13 @@ + + + typedef struct cp_list { +- long cp; ++ int32_t cp; + struct ele_info *contributor; + struct cp_list *next; + } CP_t; + + typedef struct bd_list { +- long bd; ++ int32_t bd; + int support; + struct bd_list *next; + } BD_t; +@@ -24,7 +23,7 @@ + int index; + char type; /* 'p', 's', 'c' */ + int direction; /* for clustering elements in consistent directions */ +- long score; /* for edge_filt, to solve the PPS problem */ ++ int32_t score; /* for edge_filt, to solve the PPS problem */ + struct ele_info *ele1_info, *ele2_info; + } EDGE_t; + +@@ -67,6 +66,7 @@ + struct ele_list *next; + } ELE_DATA_t; + ++ + typedef struct family { + int index; + char name[10]; +@@ -139,21 +139,45 @@ + void frag_data_free(FRAG_DATA_t **); + void frag_data_cleanup(FRAG_DATA_t **); + +- ++void print_ele_info(ELE_INFO_t *rt); ++void print_ele_data(ELE_DATA_t *rt); + + /*MSP_DATA_t *all_msps=NULL; + EDGE_t *efav=NULL;*/ + ELE_INFO_t **all_ele; + int ele_ct, ele_array_size, fam_ct; + int clan_size, clan_core_size; +-long msp_in_mem, msp_left, msp_ct, msp_index; +-long edge_index, edge_in_mem, edge_left, edge_ct; +-long files_read, clan_ct, err_no; ++int32_t msp_in_mem, msp_left, msp_ct, msp_index; ++int32_t edge_index, edge_in_mem, edge_left, edge_ct; ++int32_t files_read, clan_ct, err_no; + ELE_INFO_t *ele_info_data, *ele_info_tail; + FAM_DATA_t *FAMs; + FILE *err, *new_msps, *eles, *unproc, *combo, *obs, *fams, *log_file; + + ++/*************** ++ * DEBUG * ++ ***************/ ++ ++void print_ele_data(ELE_DATA_t *rt) { ++ if (!rt) return; ++ print_ele_info( rt->ele_info ); ++ if (rt->next) ++ print_ele_data(rt->next); ++} ++ ++void print_ele_info(ELE_INFO_t *rt) { ++ if (!rt) return; ++ printf("ele: index=%d, stat=%c, file_update=%d", rt->index, rt->stat, ++ rt->file_updated ); ++ if ( rt->to_family ) ++ printf(" family_index=%d,", rt->to_family->index ); ++ if ( rt->ele ) ++ printf(" ele_index=%d", rt->ele->index ); ++ else ++ printf(" ele=NULL"); ++ printf("\n"); ++} + + + +@@ -1341,7 +1365,7 @@ + + + +- ++/* Unused */ + void msp_data_free(MSP_DATA_t **md) { + MSP_DATA_t *cur, *next; + +diff -ruN RECON1.05/src/eleredef.c RECON-1.08/src/eleredef.c +--- RECON1.05/src/eleredef.c 2002-03-22 14:01:54.000000000 -0600 ++++ RECON-1.08/src/eleredef.c 2014-02-05 16:05:18.000000000 -0600 +@@ -51,7 +51,7 @@ + BD_t *CP_cluster(CP_t *); + void CP_sort(CP_t **); + void BD_sort(BD_t **); +-int span(ELEMENT_t *, long); ++int span(ELEMENT_t *, int32_t); + void TBD_merge(ELEMENT_t *); + + void dissect(ELE_INFO_t *); +@@ -67,16 +67,16 @@ + + void edges_and_cps(ELE_INFO_t *, IMAGE_t **); + int full_length(IMAGE_t *, float); +-void add_CP(CP_t **, long, ELE_INFO_t *); +-void add_edge(ELE_INFO_t *, ELE_INFO_t *, char, long, short); ++void add_CP(CP_t **, int32_t, ELE_INFO_t *); ++void add_edge(ELE_INFO_t *, ELE_INFO_t *, char, int32_t, short); + void adjust_edge_tree(ELE_INFO_t *); + int charge_edge_array(EDGE_t **, EDGE_TREE_t *, int); + int consis_tree_build(IMG_NODE_t *, IMAGE_t *, int); + int consis(IMAGE_t *, IMAGE_t *, float); + IMG_NODE_t **node_entry(IMG_NODE_t **); + void consis_tree_free(IMG_NODE_t *); +-/*int find_prim(struct img_node *, float, long, long, short, long *, short *);*/ +-int find_prim(IMG_NODE_t *, float, long, long, long, long, long, long, long, int *, long *, short *); ++/*int find_prim(struct img_node *, float, int32_t, int32_t, short, int32_t *, short *);*/ ++int find_prim(IMG_NODE_t *, float, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int *, int32_t *, short *); + + void combo_output(ELE_INFO_t *); + void obs_output(ELE_INFO_t *); +@@ -90,9 +90,6 @@ + + + +- +- +- + int main (int argc, char *argv[]) { + ELE_INFO_t *cur_ele_info; + int i, ele_march, ei, rounds=0, start; +@@ -125,7 +122,6 @@ + printf("Can not open naive_ele_no. Exiting\n"); + exit(1); + } +- + msp_no = fopen("summary/redef_msp_no", "r"); + if (!msp_no) msp_no = fopen("summary/ori_msp_no", "r"); + if (!msp_no) { +@@ -133,15 +129,46 @@ + exit(1); + } + ++ // May or may not exist. All uses of edge_no first check for ++ // its existence. + edge_no = fopen("summary/naive_edge_no", "r"); ++ ++ // May or may not exist. All uses are checked. + size_list = fopen("tmp/size_list", "r"); ++ ++ // May or may not exist. All uses are checked. + new_stat = fopen("tmp2/redef_stat", "r"); + + new_msps = fopen("summary/new_msps", "a"); ++ if ( !new_msps ) ++ { ++ printf("Can not open summary/new_msps for writing! Exiting\n"); ++ exit(1); ++ } + unproc = fopen("summary/unproc", "a"); ++ if ( !unproc ) ++ { ++ printf("Can not open summary/unproc for writing! Exiting\n"); ++ exit(1); ++ } + combo = fopen("summary/combo", "a"); ++ if ( !combo ) ++ { ++ printf("Can not open summary/combo for writing! Exiting\n"); ++ exit(1); ++ } + obs = fopen("summary/obsolete", "a"); ++ if ( !obs ) ++ { ++ printf("Can not open summary/obsolete for writing! Exiting\n"); ++ exit(1); ++ } + log_file = fopen("tmp2/log", "a"); ++ if ( !log_file ) ++ { ++ printf("Can not open tmp2/log for writing! Exiting\n"); ++ exit(1); ++ } + + while (fgets(line, 15, ele_no)) { + ele_ct = atoi(line); +@@ -170,7 +197,7 @@ + if (size_list && !new_stat) outthrow_big_tandems(size_list); + fclose(unproc); + +- /* set file_updated for ele_info's */ ++ /* set file_updated / stat for ele_info's */ + if (new_stat) { + ele_ct = 0; + while (fgets(line, 35, new_stat)) { +@@ -207,6 +234,12 @@ + /* re-define elements using the syntopy algorithm, and build edges */ + img_ptr = (IMAGE_t **) malloc(MAX_IMG*sizeof(IMAGE_t *)); + ++ if ( ! img_ptr ) ++ { ++ printf("eleredef: Error! Could not allocate memory for img_ptr: %d bytes requested\n", ( MAX_IMG*sizeof(IMAGE_t *) ) ); ++ exit(-1); ++ } ++ + to_march = 1; + while (to_march) { + to_march = 0; +@@ -529,6 +562,11 @@ + fprintf(log_file, "new clan: %d for ele %d\n", clan_ct, ele_info->index); + fflush(log_file); + build_local_network(ele_info, &local_net, &local_net_tail, img_ptr); ++ if ( ele_info->index == 362 || ele_info->index == 10 ) ++ { ++ printf("Printing local net for 362\n"); ++ print_ele_data( local_net ); ++ } + fprintf(log_file, "clan size: %d, clan core size: %d\n", clan_size, clan_core_size); + fflush(log_file); + /* redefining elements in the local network */ +@@ -1136,7 +1174,7 @@ + + #if 0 + BD_t *CP_cluster(CP_t *cps) { +- long first = cps->cp, last = cps->cp, sum = 0; ++ int32_t first = cps->cp, last = cps->cp, sum = 0; + int cpct = 0; + BD_t *bds = NULL, *bd_tmp; + +@@ -1171,7 +1209,7 @@ + + + BD_t *CP_cluster(CP_t *cps) { +- long first = cps->cp, last = cps->cp, sum = 0; ++ int32_t first = cps->cp, last = cps->cp, sum = 0; + CP_t *begin = cps; + int cpct = 0; + BD_t *bds = NULL, *bd_tmp; +@@ -1276,7 +1314,7 @@ + + + +-int span(ELEMENT_t *ele, long cut) { ++int span(ELEMENT_t *ele, int32_t cut) { + /* span requires PCP sorted according to cp_cmp and images sorted according to frag_cmp */ + int left=0, rite=0; + IMG_DATA_t *id; +@@ -1348,18 +1386,20 @@ + dissected = 0; + img_partner = partner(cur_img_data->to_image); + ele_partner = img_partner->ele_info->ele; +- if (full_length(img_partner, CUTOFF2)) ele_partner->flimg_no --; ++ if (full_length(img_partner, CUTOFF2)){ ++ ele_partner->flimg_no --; ++ } + tbd_tmp = cur_ele->TBD; + while (tbd_tmp != NULL) { + if (tbd_tmp->bd > cur_img_data->to_image->frag.lb || !tbd_tmp->next) { + if (tbd_tmp->bd > cur_img_data->to_image->frag.lb && tbd_tmp->bd < cur_img_data->to_image->frag.rb) { + if (tbd_tmp->bd - cur_img_data->to_image->frag.lb <= TOO_SHORT) { +- cur_img_data->to_image->to_msp->score = (long) (cur_img_data->to_image->frag.rb-tbd_tmp->bd+1.)/(cur_img_data->to_image->frag.rb-cur_img_data->to_image->frag.lb+1.)*cur_img_data->to_image->to_msp->score; ++ cur_img_data->to_image->to_msp->score = (int32_t) (cur_img_data->to_image->frag.rb-tbd_tmp->bd+1.)/(cur_img_data->to_image->frag.rb-cur_img_data->to_image->frag.lb+1.)*cur_img_data->to_image->to_msp->score; + if (cur_img_data->to_image->to_msp->direction == 1) img_partner->frag.lb += tbd_tmp->bd - cur_img_data->to_image->frag.lb; + else img_partner->frag.rb -= tbd_tmp->bd - cur_img_data->to_image->frag.lb; + cur_img_data->to_image->frag.lb = tbd_tmp->bd; + } else if (tbd_tmp->bd - cur_img_data->to_image->frag.rb >= -TOO_SHORT) { +- cur_img_data->to_image->to_msp->score = (long) (tbd_tmp->bd-cur_img_data->to_image->frag.lb+1.)/(cur_img_data->to_image->frag.rb-cur_img_data->to_image->frag.lb+1.)*cur_img_data->to_image->to_msp->score; ++ cur_img_data->to_image->to_msp->score = (int32_t) (tbd_tmp->bd-cur_img_data->to_image->frag.lb+1.)/(cur_img_data->to_image->frag.rb-cur_img_data->to_image->frag.lb+1.)*cur_img_data->to_image->to_msp->score; + if (cur_img_data->to_image->to_msp->direction == 1) img_partner->frag.rb -= cur_img_data->to_image->frag.rb - tbd_tmp->bd; + else img_partner->frag.lb += cur_img_data->to_image->frag.rb - tbd_tmp->bd; + cur_img_data->to_image->frag.rb = tbd_tmp->bd; +@@ -1375,8 +1415,11 @@ + target_img = &msp_tmp->sbjct; + target_partner = &msp_tmp->query; + } +- msp_tmp->score = (long) (tbd_tmp->bd-target_img->frag.lb+1.)/(target_img->frag.rb-target_img->frag.lb+1.)*msp_tmp->score; ++ msp_tmp->score = (int32_t) (tbd_tmp->bd-target_img->frag.lb+1.)/(target_img->frag.rb-target_img->frag.lb+1.)*msp_tmp->score; + if (msp_tmp->direction == 1) { ++ // RMH: When tracking down the divide by zero problem I ended up signaling this ++ // spot in the code as the likely place where things went initially wrong. ++ // Explore further. + target_partner->frag.rb -= target_img->frag.rb - tbd_tmp->bd; + } + else { +@@ -1715,7 +1758,7 @@ + ELE_DATA_t *ele_data_tmp; + IMG_DATA_t *scovs; + +- long max_score=0; ++ int32_t max_score=0; + short dir; + + /* sort unprocessed images according to their partner element, and then their left bounds */ +@@ -1862,7 +1905,10 @@ + + + +- ++/* NOTE: Due to the difference in computational precesion between 32bit ++ * and 64 bit processors the following function may return differing ++ * results. ++ */ + int full_length(IMAGE_t *i, float cutoff) { + if (!i->ele_info->ele) { + err_no ++; +@@ -1879,7 +1925,7 @@ + + + +-void add_CP(CP_t **CP_ptr, long cp, ELE_INFO_t *cont) { ++void add_CP(CP_t **CP_ptr, int32_t cp, ELE_INFO_t *cont) { + CP_t *new = (CP_t *) malloc(sizeof(CP_t)); + new->cp = cp; + new->contributor = cont; +@@ -1889,7 +1935,7 @@ + + + +-void add_edge(ELE_INFO_t *ele1_info, ELE_INFO_t *ele2_info, char type, long score, short dir) { ++void add_edge(ELE_INFO_t *ele1_info, ELE_INFO_t *ele2_info, char type, int32_t score, short dir) { + EDGE_t *new = EDGE_malloc(); + int ct; + +@@ -2078,7 +2124,7 @@ + */ + + #if 0 +-int find_prim(IMG_NODE_t *nd, float cutoff, long score, long hist, short which, long *sc, short *d) { ++int find_prim(IMG_NODE_t *nd, float cutoff, int32_t score, int32_t hist, short which, int32_t *sc, short *d) { + IMG_NODE_t *nex_node; + int sum = 0; + short level, further = 0; +@@ -2143,9 +2189,9 @@ + + + +-int find_prim(IMG_NODE_t *nd, float cutoff, long end1, long end2, long efl1, long efl2, long al1, long al2, long score, int *pmarkp, long *sc, short *d) { ++int find_prim(IMG_NODE_t *nd, float cutoff, int32_t end1, int32_t end2, int32_t efl1, int32_t efl2, int32_t al1, int32_t al2, int32_t score, int *pmarkp, int32_t *sc, short *d) { + int sum = 0, mark=0; +- long skip1, skip2, len1, len2; ++ int32_t skip1, skip2, len1, len2; + IMAGE_t *ipt; + + if (nd->sib) sum += find_prim(nd->sib, cutoff, end1, end2, efl1, efl2, al1, al2, score, pmarkp, sc, d); +@@ -2169,7 +2215,7 @@ + efl2 += len2; + al1 += len1; + al2 += len2; +- score += ((long) nd->to_image->to_msp->iden)*(len1+len2)/2; ++ score += ((int32_t) nd->to_image->to_msp->iden)*(len1+len2)/2; + + if (nd->children) { + end1 = nd->to_image->frag.rb; +@@ -2188,6 +2234,16 @@ + if ( (1.0*al1/efl1 > cutoff || 1.0*al2/efl2 > cutoff) && (efl1-al1 < 30 || efl2-al2 < 30) ) { + sum = 1; + mark = 1; ++ if ( (al1+al2) == 0 ) ++ { ++ // RMH: A divide by zero error has occured a few times at this point. ++ // I looked extensively through the code and cannot determine what ++ // is causing this -- although I have a reliable test case to ++ // explore this further. For now this is the only workaround. ++ // If al1 & al2 are zero then simply set them to 1. ++ printf("eleredef warning: Divide by zero averted -- setting al1 to 1.\n"); ++ al1 = 1; ++ } + score = score*2/(al1+al2); + if (score > *sc) { + *sc = score; +diff -ruN RECON1.05/src/Makefile RECON-1.08/src/Makefile +--- RECON1.05/src/Makefile 2002-01-10 15:48:02.000000000 -0600 ++++ RECON-1.08/src/Makefile 2014-02-05 16:05:18.000000000 -0600 +@@ -1,9 +1,7 @@ + # Makefile for ReCon + # + # +- +-VERSION = 1.0 +-VDATE = JUL 2001 ++VERSION = 1.08 + + ## where you want things installed + BINDIR = ../bin +@@ -13,8 +11,8 @@ + #SRCDIR = . + + ## your compiler +-CC = gcc + #CC = cc # for SGI Origin200 compiler# ++CC = gcc + + ## any special compiler flags you want + # -pedantic clashes with -DMEMDEBUG?? +@@ -121,7 +119,5 @@ + + + +- +- + + +diff -ruN RECON1.05/src/msps.h RECON-1.08/src/msps.h +--- RECON1.05/src/msps.h 2002-01-10 15:19:10.000000000 -0600 ++++ RECON-1.08/src/msps.h 2014-02-05 16:05:18.000000000 -0600 +@@ -3,14 +3,13 @@ + #include "bolts.h" + #include "seqlist.h" + +- + /* A collection of structures and functions to handle MSPs */ + + /* BASIC structures */ + + typedef struct frag { + char *seq_name; +- long lb, rb; ++ int32_t lb, rb; + /* char lst, rst; type of ends, can be used to mark physical ends */ + } FRAG_t; + +@@ -44,7 +43,7 @@ + typedef struct msp { + /*struct msp_list *hanger;*/ + char stat; /* 'p', 's' */ +- long score; ++ int32_t score; + float iden; + int direction; + IMAGE_t query, sbjct; +@@ -110,7 +109,7 @@ + + + int scan_msp(MSP_t *m, char *line) { +- long bd_tmp; ++ int32_t bd_tmp; + char qname[NAME_LEN], sname[NAME_LEN]; + int pos; + +@@ -153,7 +152,7 @@ + /* archaine */ + #if 0 + int merge_msp(MSP_t *m1, MSP_t *m2) { /* merge two MSPs into the first one */ +- long l1, l2; ++ int32_t l1, l2; + + /* no need for changing direction */ + /* iden */ +@@ -195,7 +194,7 @@ + + + int sing_cov(FRAG_t *f1, FRAG_t *f2, float cutoff) { +- long l1, l2, l, lb, rb; ++ int32_t l1, l2, l, lb, rb; + if (f1->seq_name == f2->seq_name /*!strncmp(f1->seq_name, f2->seq_name, NAME_LEN)*/) { + l1 = f1->rb - f1->lb; + l2 = f2->rb - f2->lb; +@@ -211,7 +210,7 @@ + + + int doub_cov(FRAG_t *f1, FRAG_t *f2, float cutoff) { +- long l1, l2, l, lb, rb; ++ int32_t l1, l2, l, lb, rb; + if (f1->seq_name == f2->seq_name /*!strncmp(f1->seq_name, f2->seq_name, NAME_LEN)*/) { + l1 = f1->rb - f1->lb; + l2 = f2->rb - f2->lb; +diff -ruN RECON1.05/src/seqlist.h RECON-1.08/src/seqlist.h +--- RECON1.05/src/seqlist.h 2002-01-10 15:19:10.000000000 -0600 ++++ RECON-1.08/src/seqlist.h 2014-02-05 16:05:18.000000000 -0600 +@@ -1,5 +1,6 @@ + + #include "bolts.h" ++#include "string.h" + + #ifndef _seqlist_h + #define _seqlist_h -- cgit v1.2.3-60-g2f50