chrislo-sourceclassifier 0.2.0

data/sources/gcc/recursive.gcc

@@ -0,0 +1,68 @@
+/*
+ * The Computer Language Benchmarks Game
+ * http://shootout.alioth.debian.org/
+
+ * contributed by bearophile, Jan 24 2006
+ * modified by wolfjb, Feb 28 2007
+ * modified by alex burlyga, may 16, 2008
+ */
+#include <stdio.h>
+#include <stdlib.h>
+
+static inline int ack(register int x, register int y) __attribute__((const));
+static inline int fib(int n) __attribute__((const));
+static inline double fibFP(double n) __attribute__((const));
+static inline int tak(int x, int y, int z) __attribute__((const));
+static inline double takFP(double x, double y, double z) __attribute__((const));
+
+static inline int ack(register int x, register int y){
+  if (x == 0) {
+    return y + 1;
+  }
+
+  return ack(x - 1, ((y | 0) ? ack(x, y - 1) : 1));
+}
+
+static inline int fib(register int n) {
+  if (n < 2) {
+    return 1;
+  }
+  return fib(n - 2) + fib(n - 1);
+}
+
+static inline double fibFP(double n) {
+  if (n < 2.0) {
+    return 1.0;
+  }
+  return fibFP(n - 2.0) + fibFP(n - 1.0);
+}
+
+static inline int tak(register int x, register int y, register int z) {
+  if (y < x) {
+    return tak(tak(x - 1, y, z), tak(y - 1, z, x), tak(z - 1, x, y));
+  }
+  return z;
+}
+
+static inline double takFP(double x, double y, double z) {
+    if (y < x)
+        return takFP( takFP(x-1.0, y, z), takFP(y-1.0, z, x), takFP(z-1.0, x, y) );
+    return z;
+}
+
+int
+main(int argc, char ** argv) {
+  int n = 3;
+
+  if(argc > 1) {
+    n = strtol(argv[1], NULL, 10) - 1;
+  }
+
+  printf("Ack(3,%d): %d\n", n + 1, ack(3, n+1));
+  printf("Fib(%.1f): %.1f\n", 28.0 + n, fibFP(28.0+n));
+  printf("Tak(%d,%d,%d): %d\n", 3 * n, 2 * n, n, tak(3*n, 2*n, n));
+  printf("Fib(3): %d\n", fib(3));
+  printf("Tak(3.0,2.0,1.0): %.1f\n", takFP(3.0, 2.0, 1.0));
+
+  return 0;
+}

data/sources/gcc/recursive.gcc-2.gcc

@@ -0,0 +1,55 @@
+/*
+ * The Computer Language Shootout
+ * http://shootout.alioth.debian.org/
+
+ * contributed by bearophile, Jan 24 2006
+ * modified by wolfjb, Feb 28 2007
+ */
+#include <stdio.h>
+
+int ack(int x, int y) {
+  if (x == 0) {
+    return y + 1;
+  }
+
+  return ack(x - 1, ((y | 0) ? ack(x, y - 1) : 1));
+}
+
+int fib(int n) {
+  if (n < 2) {
+    return 1;
+  }
+  return fib(n - 2) + fib(n - 1);
+}
+
+double fibFP(double n) {
+  if (n < 2.0) {
+    return 1.0;
+  }
+  return fibFP(n - 2.0) + fibFP(n - 1.0);
+}
+
+int tak(int x, int y, int z) {
+  if (y < x) {
+    return tak(tak(x - 1, y, z), tak(y - 1, z, x), tak(z - 1, x, y));
+  }
+  return z;
+}
+
+double takFP(double x, double y, double z) {
+    if (y < x)
+        return takFP( takFP(x-1.0, y, z), takFP(y-1.0, z, x), takFP(z-1.0, x, y) );
+    return z;
+}
+
+int main(int argc, char ** argv) {
+  int n = atoi(argv[1]) - 1;
+
+  printf("Ack(3,%d): %d\n", n + 1, ack(3, n+1));
+  printf("Fib(%.1f): %.1f\n", 28.0 + n, fibFP(28.0+n));
+  printf("Tak(%d,%d,%d): %d\n", 3 * n, 2 * n, n, tak(3*n, 2*n, n));
+  printf("Fib(3): %d\n", fib(3));
+  printf("Tak(3.0,2.0,1.0): %.1f\n", takFP(3.0, 2.0, 1.0));
+
+  return 0;
+}

data/sources/gcc/regexdna.gcc-2.gcc

@@ -0,0 +1,126 @@
+/*
+** The Computer Language Shootout
+** http://shootout.alioth.debian.org/
+** contributed by Mike Pall
+**
+** regex-dna benchmark using PCRE
+**
+** compile with:
+**   gcc -O3 -fomit-frame-pointer -o regexdna regexdna.c -lpcre
+*/
+
+#define __USE_STRING_INLINES
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <pcre.h>
+
+typedef struct fbuf {
+  char *buf;
+  size_t size, len;
+} fbuf_t;
+
+static void fb_init(fbuf_t *b)
+{
+  b->buf = NULL;
+  b->len = b->size = 0;
+}
+
+static char *fb_need(fbuf_t *b, size_t need)
+{
+  need += b->len;
+  if (need > b->size) {
+    if (b->size == 0) b->size = need;
+    else while (need > b->size) b->size += b->size;
+    if (!(b->buf = realloc(b->buf, b->size))) exit(1);
+  }
+  return b->buf+b->len;
+}
+
+#define FB_MINREAD	(3<<16)
+
+/* Read all of a stdio stream into dst buffer. */
+static size_t fb_readall(fbuf_t *dst, FILE *fp)
+{
+  char *dp;
+  int n;
+  for (dp = fb_need(dst, FB_MINREAD);
+       (n = fread(dp, 1, dst->size-dst->len, fp)) > 0;
+       dp = fb_need(dst, FB_MINREAD)) dst->len += n;
+  if (ferror(fp)) exit(1);
+  return dst->len;
+}
+
+/* Substitute pattern p with replacement r, copying from src to dst buffer. */
+static size_t fb_subst(fbuf_t *dst, fbuf_t *src, const char *p, const char *r)
+{
+  pcre *re;
+  pcre_extra *re_ex;
+  const char *re_e;
+  char *dp;
+  int re_eo, m[3], pos, rlen, clen;
+  if (!(re = pcre_compile(p, PCRE_CASELESS, &re_e, &re_eo, NULL))) exit(1);
+  re_ex = pcre_study(re, 0, &re_e);
+  for (dst->len = 0, rlen = strlen(r), pos = 0;
+       pcre_exec(re, re_ex, src->buf, src->len, pos, 0, m, 3) >= 0;
+       pos = m[1]) {
+    clen = m[0]-pos;
+    dp = fb_need(dst, clen+rlen);
+    dst->len += clen+rlen;
+    memcpy(dp, src->buf+pos, clen);
+    memcpy(dp+clen, r, rlen);
+  }
+  clen = src->len-pos;
+  dp = fb_need(dst, clen);
+  dst->len += clen;
+  memcpy(dp, src->buf+pos, clen);
+  return dst->len;
+}
+
+/* Count all matches with pattern p in src buffer. */
+static int fb_countmatches(fbuf_t *src, const char *p)
+{
+  pcre *re;
+  pcre_extra *re_ex;
+  const char *re_e;
+  int re_eo, m[3], pos, count;
+  if (!(re = pcre_compile(p, PCRE_CASELESS, &re_e, &re_eo, NULL))) exit(1);
+  re_ex = pcre_study(re, 0, &re_e);
+  for (count = 0, pos = 0;
+       pcre_exec(re, re_ex, src->buf, src->len, pos, 0, m, 3) >= 0;
+       pos = m[1]) count++;
+  return count;
+}
+
+static const char *variants[] = {
+  "agggtaaa|tttaccct",         "[cgt]gggtaaa|tttaccc[acg]",
+  "a[act]ggtaaa|tttacc[agt]t", "ag[act]gtaaa|tttac[agt]ct",
+  "agg[act]taaa|ttta[agt]cct", "aggg[acg]aaa|ttt[cgt]ccct",
+  "agggt[cgt]aa|tt[acg]accct", "agggta[cgt]a|t[acg]taccct",
+  "agggtaa[cgt]|[acg]ttaccct", NULL
+};
+
+static const char *subst[] = {
+  "B", "(c|g|t)", "D", "(a|g|t)",   "H", "(a|c|t)", "K", "(g|t)",
+  "M", "(a|c)",   "N", "(a|c|g|t)", "R", "(a|g)",   "S", "(c|g)",
+  "V", "(a|c|g)", "W", "(a|t)",     "Y", "(c|t)",   NULL
+};
+
+int main(int argc, char **argv)
+{
+  fbuf_t seq[2];
+  const char **pp;
+  size_t ilen, clen, slen;
+  int flip;
+  fb_init(&seq[0]);
+  fb_init(&seq[1]);
+  ilen = fb_readall(&seq[0], stdin);
+  clen = fb_subst(&seq[1], &seq[0], ">.*|\n", "");
+  for (pp = variants; *pp; pp++)
+    printf("%s %d\n", *pp, fb_countmatches(&seq[1], *pp));
+  for (slen = 0, flip = 1, pp = subst; *pp; pp += 2, flip = 1-flip)
+    slen = fb_subst(&seq[1-flip], &seq[flip], *pp, pp[1]);
+  printf("\n%zu\n%zu\n%zu\n", ilen, clen, slen);
+  return 0;
+}
+

data/sources/gcc/regexmatch.gcc

@@ -0,0 +1,136 @@
+/* -*- mode: c -*-
+ * $Id: regexmatch.gcc,v 1.1.1.1 2004-05-19 18:11:23 bfulgham Exp $
+ * http://www.bagley.org/~doug/shootout/
+ */
+
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <stdio.h>
+#include <pcre.h>
+#include <string.h>
+
+#define MAXLINES   100
+#define MAXLINELEN 132
+
+char *pattern = 
+"(?:^|[^\\d\\(])"		/* must be preceeded by non-digit */
+"(\\()?"			/* match 1: possible initial left paren */
+"(\\d\\d\\d)"			/* match 2: area code is 3 digits */
+"(?(1)\\))"			/* if match1 then match right paren */
+"[ ]"				/* area code followed by one space */
+"(\\d\\d\\d)"			/* match 3: prefix of 3 digits */
+"[ -]"				/* separator is either space or dash */
+"(\\d\\d\\d\\d)"		/* match 4: last 4 digits */
+"\\D"				/* must be followed by a non-digit */
+;
+
+
+int
+main(int argc, char *argv[]) {
+    int NUM = ((argc == 2) ? atoi(argv[1]) : 1);
+    int count;
+    char *cptr = "";
+    char **phones;
+    pcre *re;
+    int erroffset;
+    const char *errptr;
+    int n, lines = 0;
+    char num[256];
+    int i, j, k, matchlen;
+    char *matchoffset;
+    int nmatches;
+    int *ovec, ovecsize;
+    pcre_extra *study;
+
+    phones = (char **)malloc(MAXLINES * sizeof(char *));
+    if (!phones) {
+	fprintf(stderr, "malloc for phones array failed\n");
+	exit(1);
+    }
+    lines = 0;
+    while (cptr) {
+	phones[lines] = (char *)malloc(MAXLINELEN);
+	if (!phones[lines]) {
+	    fprintf(stderr, "malloc to hold line #%d failed\n", lines);
+	    exit(1);
+	}
+	cptr = fgets(phones[lines], MAXLINELEN, stdin);
+	lines++;
+	if (lines > MAXLINES) {
+	    fprintf(stderr, "MAXLINES is too small\n");
+	    exit(1);
+	}
+    }
+
+    re = pcre_compile(pattern, 0, &errptr, &erroffset, NULL);
+    if (!re) {
+	fprintf(stderr, "can't open compile regexp\n");
+	exit(1);
+    }
+
+    study = pcre_study(re, 0, &errptr);
+
+    if (pcre_fullinfo(re, NULL, PCRE_INFO_CAPTURECOUNT, &nmatches) != 0) {
+	fprintf(stderr, "pcre_fullinfo failed\n");
+	exit(1);
+    }
+    nmatches++;			/* add match of entire pattern */
+
+    ovecsize = sizeof(int) * nmatches * 3;
+    ovec = (int *)malloc(ovecsize);
+    if (!ovec) {
+	fprintf(stderr, "malloc for ovec array failed\n");
+	exit(1);
+    }
+
+    count = 0;
+    while (NUM--) {
+	for (i=0; i<lines; i++) {
+	    n = pcre_exec(re, study,
+			  phones[i], strlen(phones[i]), 0,
+			  0, ovec, ovecsize);
+	    if (n == nmatches) {
+		/* stuff the match into the buffer "num" */
+		k = 2*2;	/* initial offset into ovec */
+		/* areacode */
+		j = 0;
+		num[j++] = '(';
+		matchoffset = phones[i] + ovec[k];
+		matchlen = ovec[k+1] - ovec[k];
+		strncpy(num+j, matchoffset, matchlen);
+		j += matchlen; k += 2;
+		num[j++] = ')';
+		/* space separator */
+		num[j++] = ' ';
+		/* exchange */
+		matchoffset = phones[i] + ovec[k];
+		matchlen = ovec[k+1] - ovec[k];
+		strncpy(num+j, matchoffset, matchlen);
+		j += matchlen; k += 2;
+		/* dash */
+		num[j++] = '-';
+		/* last 4 digits */
+		matchoffset = phones[i] + ovec[k];
+		matchlen = ovec[k+1] - ovec[k];
+		strncpy(num+j, matchoffset, matchlen);
+		j += matchlen; k += 2;
+		/* with a cherry on top */
+		num[j] = 0;
+		if (0 == NUM) {
+		    count++;
+		    printf("%d: %s\n", count, num);
+		}
+	    }
+	}
+    }
+
+    for (i=0; i<MAXLINES; i++) {
+	free(phones[i]);
+    }
+    free(phones);
+    free(ovec);
+
+    return(0);
+}
+

data/sources/gcc/revcomp.gcc

@@ -0,0 +1,85 @@
+/* The Computer Language Benchmarks Game
+   http://shootout.alioth.debian.org
+   contributed by Arek Bochinski
+*/
+
+
+#define _GNU_SOURCE 1
+#include <stdio.h>
+#include <string.h>
+#include <limits.h>
+
+//conversion table
+static const char FtoCOMP[128] = {
+   0,0,0,0,0,0,0,0,0,0,0,0,0,'\n',0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+   0,'T','V','G','H',0,0,'C','D',0,0,'M',0,'K','N',0,
+   0,0,'Y','S','A',0,'B','W',0,'R',0, 0, 0,0,0,0,
+   0,'T','V','G','H',0,0,'C','D',0,0,'M',0,'K','N',0,
+   0,0,'Y','S','A',0,'B','W',0,'R',0,0,0,0,0,0
+};
+
+int main (int argc, char * argv[]) {
+    char buffer[10240];
+    int itotal=0,forward=0,end=0;
+    char peek;
+    //print header
+   printf("%s",fgets_unlocked(buffer,61,stdin));
+   while(fgets_unlocked(buffer+itotal,10239,stdin))
+   {
+      //if header is next
+      if((peek=fgetc_unlocked(stdin))=='>')
+      {
+         //get total
+         itotal+=strlen(buffer+itotal);
+         //set the reverse indexes
+         forward=0;
+         end=itotal-2;
+         //reverse the buffer and complement it
+         while(forward<end)
+         {
+            if(buffer[forward]=='\n')++forward;
+            if(buffer[end]=='\n')--end;
+            buffer[forward]^=buffer[end];
+            buffer[end]^=buffer[forward];
+            buffer[forward]^=buffer[end];
+            buffer[end]=FtoCOMP[buffer[end]];
+            buffer[forward]=FtoCOMP[buffer[forward]];
+            ++forward;
+            --end;
+         }
+         //print it out
+         puts(buffer);
+         //print out the next header if there
+         printf("%c%s",'>',fgets_unlocked(buffer,10239,stdin));
+         //reset total
+         itotal=0;
+      }
+      else{
+         //header is not next, plase character back into stdin
+         ungetc(peek,stdin);
+         //sum up the total lenght of characters in the buffer
+         itotal+=strlen(buffer+itotal);
+      }
+   }
+   //print last sequence at end of stdin 
+   itotal+=strlen(buffer+itotal);
+   //set the reverse indexes
+   forward=0;
+   end=itotal-2;
+   //reverse the buffer and complement it
+   while(forward<end)
+   {
+      if(buffer[forward]=='\n')++forward;
+      if(buffer[end]=='\n')--end;
+      buffer[forward]^=buffer[end];
+      buffer[end]^=buffer[forward];
+      buffer[forward]^=buffer[end];
+      buffer[end]=FtoCOMP[buffer[end]];
+      buffer[forward]=FtoCOMP[buffer[forward]];
+      ++forward;
+      --end;
+   }
+   puts(buffer);
+   return 0;
+}