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: [PATCH] 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
---
.../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
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
--
GitLab