chrislo-sourceclassifier 0.2.0

data/sources/gcc/revcomp.gcc-2.gcc

@@ -0,0 +1,88 @@
+#include <stdio.h>
+#include <string.h>
+#include <limits.h>
+
+static unsigned char iubpairs[][2] = {
+    {    'A',    'T'    },
+    {    'C',    'G'    },
+    {    'B',    'V'    },
+    {    'D',    'H'    },
+    {    'K',    'M'    },
+    {    'R',    'Y'    },
+    {    '\0',   '\0'   }
+};
+
+static unsigned char iubComplement[1+UCHAR_MAX];
+
+static void buildIubComplement (void) {
+    int i;
+    for (i=0; i <= UCHAR_MAX; i++) iubComplement[i] = (unsigned char) i;
+    for (i=0; iubpairs[i][0] != '\0'; i++) {
+    	iubComplement[iubpairs[i][0]] = iubpairs[i][1];
+    	iubComplement[iubpairs[i][1]] = iubpairs[i][0];
+    	iubComplement[tolower (iubpairs[i][0])] = iubpairs[i][1];
+    	iubComplement[tolower (iubpairs[i][1])] = iubpairs[i][0];
+    }
+}
+
+static void inPlaceReverse (unsigned char * strand, int len) {
+    int i;
+    for (i=0, len--; i < len; i++,len--) {
+    	unsigned char c = strand[i];
+    	strand[i] = iubComplement[strand[len]];
+    	strand[len] = iubComplement[c];
+    }
+    if (i == len) strand[i] = iubComplement[strand[i]];
+}
+
+static void process (char * strand, int len) {
+    char * s, c;
+
+    inPlaceReverse ((unsigned char *) strand, len);
+    s = strand;
+
+    while (len > 60) {
+    	c = s[60];
+    	s[60] = '\0';
+    	puts (s);
+    	s[60] = c;
+    	s += 60;
+    	len -= 60;
+    }
+
+    s[len] = '\0';
+    puts (s);
+}
+
+int main (int argc, char * argv[]) {
+    static char buffer[1024];
+    char * inp = (char *) malloc (129);
+    int mlen = 128;
+    int slen = 0;
+
+    buildIubComplement ();
+
+    while (NULL != fgets (buffer, 1023, stdin)) {
+    	if (buffer[0] == '>') {
+    	    if (slen > 0) {
+    	    	process (inp, slen);
+    	    	slen = 0;
+    	    }
+    	    printf ("%s", buffer);
+    	} else {
+    	    int l = strlen (buffer);
+    	    while (l > 0 && !isalpha (buffer[l-1])) l--;
+    	    while (slen + l > mlen) {
+    	    	mlen += mlen;
+    	    	inp = (char *) realloc (inp, mlen + 1);
+    	    }
+
+    	    memcpy (inp + slen, buffer, l);
+    	    slen += l;
+    	}
+    }
+    if (slen > 0) process (inp, slen);
+    free (inp);
+    return 0;
+}
+

data/sources/gcc/revcomp.gcc-4.gcc

@@ -0,0 +1,71 @@
+/*
+ * The Computer Language Benchmarks Game
+ * http://shootout.alioth.debian.org
+ *
+ * contributed by Bob W 
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+
+#define JBFSIZE 82      // line input buffer size
+#define QBFSIZE 5200     // output buffer initial size
+#define Z16     "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
+#define V32     "\0TVGH\0\0CD\0\0M\0KN\0\0\0YSA\0BW\0R\0\0\0\0\0\0"
+#define VALL    Z16 Z16 Z16 Z16 V32 V32 Z16 Z16 Z16 Z16 Z16 Z16 Z16 Z16
+
+int errex(char *s, int n) {      // error message+value, return 1
+  fprintf(stderr,"\n*** Error: %s [%d]!\n", s, n);
+  return 1;
+}
+
+int main () {                    // ***** main *****
+  char *pj, *pq, *pr;            // buffer pointers: inp,out,/out
+  char *jjj = malloc(JBFSIZE);   // allocate input line buffer
+  char *qqq = malloc(QBFSIZE);   // output buffer (dyn. size)
+  char *pqstop = qqq+QBFSIZE;    // end-of-buffer pointer
+  char xtab[256] = VALL;         // char conversion table
+
+  if (!jjj || !qqq)
+    return errex("Buffer allocation", !jjj + !qqq);
+  pj = fgets(jjj,JBFSIZE,stdin);         // fetch 1st line
+  if (!pj)
+    return errex("No input data",0);
+  if (*jjj != '>')
+    return errex("1st char not '>'", 0);
+
+  while (pj) {                           // MAIN LOOP: process data
+    fputs(jjj, stdout);                  // output ID line
+
+    for (pq=qqq+1, pr=pqstop; ; pq++) {  // LOOP: fill output buffer
+      pj = fgets(jjj, JBFSIZE, stdin);   // get line from stdin
+      if (!pj || (*jjj=='>'))  break;    // EOF or new ID line
+      if (pr <= (pq+61)) {               // need to resize buffer
+        char *newstop = pqstop + 12777888;
+        char *newptr  = realloc(qqq, newstop-qqq);
+        if (!newptr)
+          return errex("Out of memory", 0);
+        if (newptr != qqq) {             // new base: adj. pointers
+          size_t x = newptr-qqq;         // offset for pointer update
+          pq+=x;  pr+=x;  qqq+=x;
+          newstop+=x;  pqstop+=x;
+        }
+        pr = __builtin_memmove(newstop-(pqstop-pr), pr, pqstop-pr);
+        pqstop = newstop;                // buffer resize complete
+      }
+      while (*pj) {                      // LOOP: conv. & revert line
+        char c = xtab[(unsigned char)(*pj++)];
+        if (c)                           // conversion valid
+          *(--pr) = c;
+      }
+    }
+
+    for (pq = qqq; pr<pqstop; ) {        // LOOP: format output
+      size_t x = (pqstop-pr)<60 ? pqstop-pr : 60;
+      __builtin_memmove(pq,pr,x);        // move line to free space
+      pr+=x;  pq+=x;  *(pq++) = 0xA;     // adjust pointers, add LF
+    }
+    fwrite(qqq, 1, pq-qqq, stdout);      // output converted data
+  }
+  return 0;
+}

data/sources/gcc/reversefile.gcc

@@ -0,0 +1,103 @@
+/* -*- mode: c -*-
+ * $Id: reversefile.gcc,v 1.5 2004-10-18 07:15:07 bfulgham Exp $
+ * http://shootout.alioth.debian.org/
+ * 
+ * from Alan Post <apost@recalcitrant.org>
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <assert.h>
+#include <limits.h>
+#include <sys/uio.h>
+
+#define MAXREAD 4096
+#define IOV_MAX 1024
+
+typedef struct buf_t { char d[MAXREAD];
+                       size_t len;
+                       struct buf_t *next;} buf_t;
+
+static print_string( char *data, size_t len,
+                     struct iovec *vec, size_t *p_ivec )
+{
+    vec[ *p_ivec ].iov_base = data;
+    vec[ *p_ivec ].iov_len = (int) len;
+    ++ *p_ivec;
+    if ( *p_ivec == IOV_MAX )
+    {
+        writev( STDOUT_FILENO, vec, *p_ivec );
+        *p_ivec = 0;
+    }
+}
+
+static print_line( char *pos, char *end, buf_t **p_loh,
+                   struct iovec *vec, size_t *p_ivec )
+{
+    print_string( pos, end - pos, vec, p_ivec );
+    for (; *p_loh != NULL; *p_loh = (*p_loh)->next )
+        print_string( (*p_loh)->d, (*p_loh)->len, vec, p_ivec );
+}
+
+static void rev_print( buf_t *head )
+{
+    buf_t *loh = NULL;
+    buf_t *curr = head;
+
+    struct iovec vec[ IOV_MAX ];
+    size_t ivec = 0;
+
+    while ( 1 )
+    {
+        char *buf = curr->d;
+        char *end = buf + curr->len;
+        char *pos = end;
+        for (;; pos--)
+        {
+            if ( pos <= buf )
+            {
+                buf_t *new_curr = curr->next;
+
+                if ( new_curr == NULL )
+                {
+                    print_line( pos, end, &loh, vec, &ivec );
+                    writev( STDOUT_FILENO, vec, ivec );
+                    return;
+                }
+
+                curr->len = end - buf;
+                curr->next = loh;
+                loh = curr;
+                
+                curr = new_curr;
+                break;
+            }
+            if ( *(pos-1) == '\n' )
+            {
+                print_line( pos, end, &loh, vec, &ivec );
+                end = pos;
+            }
+        }
+    }
+    assert( NULL == "unreachable" );
+}
+
+static void f( buf_t *tail )
+{
+    buf_t head;
+
+    head.next = tail;
+    head.len = read( STDIN_FILENO, head.d, MAXREAD );
+
+    if ( head.len == MAXREAD ) f( &head );
+    else rev_print( &head );
+}
+
+int main(int argc, char *argv[])
+{
+    f( NULL );
+    return EXIT_SUCCESS;
+}
+

data/sources/gcc/reversefile.gcc-2.gcc

@@ -0,0 +1,56 @@
+/* -*- mode: c -*-
+ * $Id: reversefile.gcc-2.gcc,v 1.1 2004-11-10 06:51:38 bfulgham Exp $
+ * http://www.bagley.org/~doug/shootout/
+ */
+
+/* this version attempts to read the file line by line instead of
+   all at once. */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
+#define BLKSIZE 16 * 1024
+
+int main(int argc, char *argv[]) {
+    int nread, size, len;
+    char *cp, *offset, *buf = malloc(BLKSIZE + 1);
+
+    offset = buf;
+    size = len = BLKSIZE;
+    while (1) {
+	nread = read(0, offset, len);
+	if (0 == nread) break;
+	if (-1 == nread) {
+	    perror("read");
+	    exit(1);
+	}
+	offset += nread;
+	len -= nread;
+	if (0 == len) {
+	    len = size;
+	    size *= 2;
+	    if (0 == (cp = realloc(buf, size + 1))) {
+		fprintf(stderr, "realloc failed\n");
+		exit(1);
+	    }
+	    buf = cp;
+	    offset = buf + len;
+	}
+    }
+    *offset = 0;
+    for (cp = offset; cp > buf; --cp) {
+	if ('\n' == *cp) {
+	    *offset = 0;
+	    if (cp < offset)
+		printf(offset = cp+1);
+	}
+    }
+    if (cp < offset) {
+	*offset = 0;
+	printf(cp);
+    }
+    free(buf);
+    return(0);
+}

data/sources/gcc/sieve.gcc

@@ -0,0 +1,34 @@
+/* -*- mode: c -*-
+ * $Id: sieve.gcc,v 1.1.1.1 2004-05-19 18:12:27 bfulgham Exp $
+ * http://www.bagley.org/~doug/shootout/
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+
+int
+main(int argc, char *argv[]) {
+    int NUM = ((argc == 2) ? atoi(argv[1]) : 1);
+    static char flags[8192 + 1];
+    long i, k;
+    int count = 0;
+
+    while (NUM--) {
+	count = 0; 
+	for (i=2; i <= 8192; i++) {
+	    flags[i] = 1;
+	}
+	for (i=2; i <= 8192; i++) {
+	    if (flags[i]) {
+		// remove all multiples of prime: i
+		for (k=i+i; k <= 8192; k+=i) {
+		    flags[k] = 0;
+		}
+		count++;
+	    }
+	}
+    }
+    printf("Count: %d\n", count);
+    return(0);
+}
+

data/sources/gcc/spectralnorm.gcc

@@ -0,0 +1,54 @@
+/* -*- mode: c -*-
+ * 
+ * The Great Computer Language Shootout
+ * http://shootout.alioth.debian.org/
+ *
+ * Contributed by Sebastien Loisel
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <math.h>
+
+double eval_A(int i, int j) { return 1.0/((i+j)*(i+j+1)/2+i+1); }
+
+void eval_A_times_u(int N, const double u[], double Au[])
+{
+  int i,j;
+  for(i=0;i<N;i++)
+    {
+      Au[i]=0;
+      for(j=0;j<N;j++) Au[i]+=eval_A(i,j)*u[j];
+    }
+}
+
+void eval_At_times_u(int N, const double u[], double Au[])
+{
+  int i,j;
+  for(i=0;i<N;i++)
+    {
+      Au[i]=0;
+      for(j=0;j<N;j++) Au[i]+=eval_A(j,i)*u[j];
+    }
+}
+
+void eval_AtA_times_u(int N, const double u[], double AtAu[])
+{ double v[N]; eval_A_times_u(N,u,v); eval_At_times_u(N,v,AtAu); }
+
+int main(int argc, char *argv[])
+{
+  int i;
+  int N = ((argc == 2) ? atoi(argv[1]) : 2000);
+  double u[N],v[N],vBv,vv;
+  for(i=0;i<N;i++) u[i]=1;
+  for(i=0;i<10;i++)
+    {
+      eval_AtA_times_u(N,u,v);
+      eval_AtA_times_u(N,v,u);
+    }
+  vBv=vv=0;
+  for(i=0;i<N;i++) { vBv+=u[i]*v[i]; vv+=v[i]*v[i]; }
+  printf("%0.9f\n",sqrt(vBv/vv));
+  return 0;
+}
+

data/sources/gcc/spellcheck.gcc

@@ -0,0 +1,72 @@
+/* -*- mode: c -*-
+ * $Id: spellcheck.gcc,v 1.1.1.1 2004-05-19 18:13:26 bfulgham Exp $
+ * http://www.bagley.org/~doug/shootout/
+ * with help from Brad Knotwell
+ */
+
+#include <ctype.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include "simple_hash.h"
+
+#define MAXLINELEN 128
+
+struct ht_ht *dict = NULL;
+
+int handleInput(FILE *input,void (*hashManipFn)(char *))
+{
+    int wordbufsize = 80,i = 0;
+    char *cp, *wordbuf = (char *)malloc(wordbufsize + 1);
+    char line[MAXLINELEN];
+    
+    if((wordbuf = malloc(wordbufsize+1)) == NULL) 
+        return(fprintf(stderr,"malloc\n"),0);
+
+    while (fgets(line, MAXLINELEN, input))
+	for (cp=line; *cp > 0; cp++) {
+	    if (isspace(*cp)) {
+		if (i) {
+		    wordbuf[i] = '\0';
+                    hashManipFn(wordbuf);
+		    i = 0;
+		}
+	    } else {
+		wordbuf[i++] = *cp;
+		if (i == wordbufsize) {
+		    wordbufsize *= 2;
+		    if((wordbuf = realloc(wordbuf, wordbufsize + 1)) == NULL)
+                        return(fprintf(stderr, "realloc\n"), 0);
+		}
+	    }
+        }
+
+    free(wordbuf);
+    return(1);
+}
+
+void spellCheck(char *key) { 
+    if (ht_find_new(dict,key)->val != 1) printf("%s\n",key);
+}
+
+void hashLoad(char *key) { ht_find_new(dict,key)->val = 1; }
+ 
+int main(int argc, char *argv[]) {
+    FILE *fh;
+    int rc;
+
+    /*  
+        ht_create doesn't handle malloc and calloc failures 
+        so this is superfluous 
+    */
+    if((dict = ht_create(40000)) == NULL)
+        return(fprintf(stderr,"hash creation failed\n"),EXIT_FAILURE);
+    
+    if ((fh = fopen("Usr.Dict.Words", "r")) == NULL) 
+        return(fprintf(stderr,"couldn't open dictionary\n"),EXIT_FAILURE);
+
+    rc = ((handleInput(fh,hashLoad) && handleInput(stdin,spellCheck)) ? EXIT_SUCCESS : EXIT_FAILURE);
+
+    ht_destroy(dict);
+    return(rc);
+}