initial commit

Author: Brian C. Thomas

.gitignore

@@ -0,0 +1,3 @@
+*.swp
+*.o
+*.gch

Makefile

@@ -0,0 +1,42 @@
+PROGRAM_NAME = main
+VERSION = 0.1
+CC = gcc
+CFLAGS = -g -Wall -pedantic -DVERSION=$(VERSION)
+DEBUG = -g
+OPT = -O3
+ARCHIVE = $(PROGRAM_NAME)_$(VERSION)
+LDFLAGS = -lz
+SDIR = src
+BDIR = build
+
+.PHONY: clean default build distclean dist debug
+
+default: build
+
+file_read.o: $(SDIR)/file_read.c $(SDIR)/file_read.h
+	$(CC) $(CFLAGS) $(OPT) -c $(SDIR)/$*.c # -o $(SDIR)/$*.o
+
+linked_list.o: $(SDIR)/linked_list.c $(SDIR)/linked_list.h
+	$(CC) $(CFLAGS) $(OPT) -c $(SDIR)/$*.c # -o $(SDIR)/$*.o
+
+pull_from_list.o: $(SDIR)/pull_from_list.c $(SDIR)/pull_from_list.h $(SDIR)/kseq.h
+	$(CC) $(CFLAGS) $(OPT) -c $(SDIR)/$*.c # -o $(SDIR)/$*.o
+
+pullseq.o: $(SDIR)/pullseq.c
+	$(CC) $(CFLAGS) $(OPT) -c $(SDIR)/$*.c # -o $(SDIR)/$*.o
+
+clean:
+	rm -rf *.o $(BDIR)/*.o $(SDIR)/*.gch ./pullseq
+
+distclean: clean
+	rm -rf *.tar.gz
+
+dist:
+	tar -zcf $(ARCHIVE).tar.gz *.ch Makefile
+
+build: file_read.o linked_list.o pull_from_list.o pullseq.o
+	$(CC) $(CFLAGS) $(LDFLAGS) $(OPT) $? -o pullseq
+
+debug:
+	$(MAKE) build "CFLAGS=-Wall -pedantic -g -DDEBUG"
+

code.txt

@@ -0,0 +1,17 @@
+A) size filters
+Open fasta/fastq file
+Foreach fasta/fastq in file
+ o if sequence length passes the size filters, print
+
+B) contig list filters
+Open contig list file
+ o read in first word on each line
+ o store in a linked list
+
+Open fasta/fastq file
+Foreach fasta/fastq in file
+ o if sequence length passes the size filters, print
+
+main()
+
+

readme.txt

@@ -0,0 +1,63 @@
+Summary:
+  pullseq: extract sequences from a fasta/fastq file
+
+Synopsis:
+  # general extraction with a list of names
+  pullseq --input=<input fasta/fastq file> --names=<fasta header ids file>
+  
+  # general extraction with a minimum size requirement
+  pullseq --input=<input fasta/fastq file> --min=<minimum size sequence to extract>
+  
+  # only sequences with min 200 and max 500
+  pullseq -i input.fasta -m 200 -a 500 > new.fasta
+
+Options:
+    --input, -i <s>:   contig file (fasta format)
+    --names, -n <s>:   file containing single column list of contig_ids
+      --min, -m <i>:   minimum size contig to pull
+      --max, -a <i>:   maximum size contig to pull
+      --exclude, -e:   contigs list will be excluded
+      --version, -v:   Print version and exit
+         --help, -h:   Show this message
+
+
+
+
+# c parts
+1. sequence parts
+kseq.h:
+  kseq_t
+  kstring_t
+
+2. filter file list
+
+struct
+  list
+
+linked_list
+readline # read from input
+ FILE
+parseline # grab 1st word
+
+main
+filter # find matching header or minimum/maximum seq length
+print # dump to file or if -o option, open file and dump
+
+Scenarios
+1) given a fasta file and a file of header names to select
+  open header names file
+  read each line and extract the first word
+  create a linked_list node for the word
+  close the file
+  open the fasta file
+  read each kseq_t entry
+  search for kseq_t entry in linked list of header names
+  if found, print
+  close fasta file
+
+2) given a fasta file and a minimum length
+  open the fasta file
+  read each kseq_t entry
+  search for kseq_t entry where sequence length >= cutoff
+  if found, print
+  close fasta file

src/file_read.c

@@ -0,0 +1,141 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <errno.h>
+#include <limits.h>
+
+#include "file_read.h"
+
+char *parse_name(char *line)
+{
+  char *word;
+  char *delims = " \t\n"; /* space, tab, newline */
+  word = strtok(line,delims);
+  return word;
+}
+
+#define BUFSIZE 80
+int getl(char **lineptr, FILE *fp) {
+  char ch;
+  ssize_t buf_pos = 0;
+  ssize_t count = 2; /* Always buf_pos + 2 (see below). */
+  size_t new_length = 0;
+  size_t n = BUFSIZE;
+  char *temp;
+
+  if ((lineptr == NULL) || (fp == NULL)) {
+    errno = EINVAL;
+    return -1;
+  }
+
+  if (errno != 0)
+    errno = 0;
+
+  if ((*lineptr == NULL)) {
+    *lineptr = malloc(n * sizeof(char));
+
+    if (*lineptr == NULL) {
+      return -1; /* Out of memory. */
+    }
+  }
+
+  /*
+   * There are buf_pos characters in the buffer.  When we read another
+   * character, we want to store it, and we also need enough
+   * room for a nul string. So we need to realloc as soon as our capacity
+   * becomes less than buf_pos + 2.
+   * Hence the variable "count" which always equals buf_pos + 2.
+   */
+
+  while ((ch = getc(fp)) != EOF) {
+    if (errno != 0)
+      return -1;
+
+    if (count > n) { /* current chars read is going to blow our buffer - add more */
+      new_length = n * 2; /* double the current buffer size */
+      if (new_length <= n) { /* Overflow. */
+        errno = ENOMEM;
+        /* We couldn't store the character, */
+        /* so put it back on the stream. */
+        ungetc(ch, fp);
+        return -1;
+      }
+      temp = (char *)realloc(*lineptr, new_length * sizeof(char)); /* realloc to a temp */
+      if (temp == NULL) {
+        ungetc(ch, fp);
+        return -1;
+      }
+      n = new_length; /* set n to the new length we were able to get from system */
+      *lineptr = temp; /* set line to this new temp string */
+    }
+
+    (*lineptr)[buf_pos++] = ch; /* set this char in the string at buf_pos and THEN increment buf_pos */
+
+    if (ch == '\n') /* eol */
+      break;
+
+    if (count == SSIZE_MAX) { /* SSIZE_MAX is 32767 - posix def */
+      /* We'll overflow ssize_t on the next round, since the return
+       * type is SSIZE_T */
+      errno = ENOMEM;
+      return -1;
+    }
+    count++; /* increment ch count */
+  }
+
+  (*lineptr)[buf_pos] = '\0'; /* set last position to \0 */
+
+  if (buf_pos == 0) { /* nothing in the file? */
+    buf_pos = -1;
+  }
+  return buf_pos;
+}
+
+int getlx(char **iline,FILE *fp)
+{
+  char *line = *iline;
+  char *newline = NULL;
+  char *buf = NULL;
+  char *eol = NULL;
+  size_t capacity = sizeof(line); /* reasonable starting point for line length */
+  size_t remaining = capacity;
+  size_t used = 0;
+
+  buf = line; /* point buf -> line */
+  line[0] = '\0';
+
+  /* read file  into buf */
+  while (fgets(buf, remaining, fp)) {
+    eol = strchr(buf, '\n'); /* locate first occurrence of '\n' */
+    if (eol) { /* found a newline in the string */
+      *eol = '\0'; /* replace the newline with the null character */
+      break;
+    } else {
+      /* buffer was too small - enlarge it */
+      used = buf + remaining - line;
+      
+      newline = realloc(line, capacity * 2);
+      if (!newline) {
+        fprintf(stderr, "getl - realloc: %s\n", strerror(errno));
+        return -1;
+      } else {
+        line = newline;
+      }
+
+      buf = line + used - 1;
+      capacity *= 2;
+      remaining = capacity - used;
+    }
+  }
+
+  if (errno) {
+    fprintf(stderr, "getl - fgets: %s\n", strerror(errno));
+  } else if (line[0]) {
+    char *eol = strchr(buf, '\n');
+    if (eol)
+      *eol = '\0';
+    /*buf = line;*/
+    return strlen(line);
+  }
+  return -1;
+}

src/file_read.h

@@ -0,0 +1,6 @@
+#ifndef __FILE_READ_H__
+#define __FILE_READ_H__
+#endif
+
+int getl(char **line, FILE *fp);
+char *parse_name(char *line);

src/global.h

@@ -0,0 +1,8 @@
+#ifndef __GLOBAL_H__
+#define __GLOBAL_H__
+#endif
+
+#define _POSIX_C_SOURCE 200809L
+
+static int verbose_flag;
+char const *progname;