tcc 0.1.0

data/ext/tcc/tcc-0.9.26/tests/tests2/23_type_coercion.expect

@@ -0,0 +1,12 @@
+char: a
+char: b
+char: c
+int: 97
+int: 98
+int: 99
+float: 97.000000
+float: 98.000000
+float: 99.000000
+97 97
+97 97
+97.000000 97.000000

data/ext/tcc/tcc-0.9.26/tests/tests2/24_math_library.c

@@ -0,0 +1,28 @@
+#include <stdio.h>
+#include <math.h>
+
+int main()
+{
+   printf("%f\n", sin(0.12));
+   printf("%f\n", cos(0.12));
+   printf("%f\n", tan(0.12));
+   printf("%f\n", asin(0.12));
+   printf("%f\n", acos(0.12));
+   printf("%f\n", atan(0.12));
+   printf("%f\n", sinh(0.12));
+   printf("%f\n", cosh(0.12));
+   printf("%f\n", tanh(0.12));
+   printf("%f\n", exp(0.12));
+   printf("%f\n", fabs(-0.12));
+   printf("%f\n", log(0.12));
+   printf("%f\n", log10(0.12));
+   printf("%f\n", pow(0.12, 0.12));
+   printf("%f\n", sqrt(0.12));
+   printf("%f\n", round(12.34));
+   printf("%f\n", ceil(12.34));
+   printf("%f\n", floor(12.34));
+
+   return 0;
+}
+
+/* vim: set expandtab ts=4 sw=3 sts=3 tw=80 :*/

data/ext/tcc/tcc-0.9.26/tests/tests2/24_math_library.expect

@@ -0,0 +1,18 @@
+0.119712
+0.992809
+0.120579
+0.120290
+1.450506
+0.119429
+0.120288
+1.007209
+0.119427
+1.127497
+0.120000
+-2.120264
+-0.920819
+0.775357
+0.346410
+12.000000
+13.000000
+12.000000

data/ext/tcc/tcc-0.9.26/tests/tests2/25_quicksort.c

@@ -0,0 +1,83 @@
+#include <stdio.h>
+
+int array[16];
+
+//Swap integer values by array indexes
+void swap(int a, int b)
+{
+   int tmp  = array[a];
+   array[a] = array[b];
+   array[b] = tmp;
+}
+
+//Partition the array into two halves and return the
+//index about which the array is partitioned
+int partition(int left, int right)
+{
+   int pivotIndex = left;
+   int pivotValue = array[pivotIndex];
+   int index = left;
+   int i;
+
+   swap(pivotIndex, right);
+   for(i = left; i < right; i++)
+   {
+      if(array[i] < pivotValue)
+      {
+         swap(i, index);
+         index += 1;
+      }
+   }
+   swap(right, index);
+
+   return index;
+}
+
+//Quicksort the array
+void quicksort(int left, int right)
+{
+   if(left >= right)
+      return;
+
+   int index = partition(left, right);
+   quicksort(left, index - 1);
+   quicksort(index + 1, right);
+}
+
+int main()
+{
+   int i;
+
+   array[0] = 62;
+   array[1] = 83;
+   array[2] = 4;
+   array[3] = 89;
+   array[4] = 36;
+   array[5] = 21;
+   array[6] = 74;
+   array[7] = 37;
+   array[8] = 65;
+   array[9] = 33;
+   array[10] = 96;
+   array[11] = 38;
+   array[12] = 53;
+   array[13] = 16;
+   array[14] = 74;
+   array[15] = 55;
+
+   for (i = 0; i < 16; i++)
+      printf("%d ", array[i]);
+
+   printf("\n");
+
+   quicksort(0, 15);
+
+   for (i = 0; i < 16; i++)
+      printf("%d ", array[i]);
+
+   printf("\n");
+
+   return 0;
+}
+
+/* vim: set expandtab ts=4 sw=3 sts=3 tw=80 :*/

data/ext/tcc/tcc-0.9.26/tests/tests2/25_quicksort.expect

@@ -0,0 +1,2 @@
+62 83 4 89 36 21 74 37 65 33 96 38 53 16 74 55 
+4 16 21 33 36 37 38 53 55 62 65 74 74 83 89 96 

data/ext/tcc/tcc-0.9.26/tests/tests2/26_character_constants.c

@@ -0,0 +1,17 @@
+#include <stdio.h>
+
+int main()
+{
+   printf("%d\n", '\1');
+   printf("%d\n", '\10');
+   printf("%d\n", '\100');
+   printf("%d\n", '\x01');
+   printf("%d\n", '\x0e');
+   printf("%d\n", '\x10');
+   printf("%d\n", '\x40');
+   printf("test \x40\n");
+
+   return 0;
+}
+
+/* vim: set expandtab ts=4 sw=3 sts=3 tw=80 :*/

data/ext/tcc/tcc-0.9.26/tests/tests2/26_character_constants.expect

@@ -0,0 +1,8 @@
+1
+8
+64
+1
+14
+16
+64
+test @

data/ext/tcc/tcc-0.9.26/tests/tests2/27_sizeof.c

@@ -0,0 +1,16 @@
+#include <stdio.h>
+
+int main()
+{
+   char a;
+   int b;
+   double c;
+
+   printf("%d\n", sizeof(a));
+   printf("%d\n", sizeof(b));
+   printf("%d\n", sizeof(c));
+
+   return 0;
+}
+
+/* vim: set expandtab ts=4 sw=3 sts=3 tw=80 :*/

data/ext/tcc/tcc-0.9.26/tests/tests2/27_sizeof.expect

@@ -0,0 +1,3 @@
+1
+4
+8

data/ext/tcc/tcc-0.9.26/tests/tests2/28_strings.c

@@ -0,0 +1,46 @@
+#include <stdio.h>
+#include <string.h>
+#include <strings.h>
+
+int main()
+{
+   char a[10];
+
+   strcpy(a, "hello");
+   printf("%s\n", a);
+
+   strncpy(a, "gosh", 2);
+   printf("%s\n", a);
+
+   printf("%d\n", strcmp(a, "apple") > 0);
+   printf("%d\n", strcmp(a, "goere") > 0);
+   printf("%d\n", strcmp(a, "zebra") < 0);
+
+   printf("%d\n", strlen(a));
+
+   strcat(a, "!");
+   printf("%s\n", a);
+
+   printf("%d\n", strncmp(a, "apple", 2) > 0);
+   printf("%d\n", strncmp(a, "goere", 2) == 0);
+   printf("%d\n", strncmp(a, "goerg", 2) == 0);
+   printf("%d\n", strncmp(a, "zebra", 2) < 0);
+
+   printf("%s\n", index(a, 'o'));
+   printf("%s\n", rindex(a, 'l'));
+   printf("%d\n", rindex(a, 'x') == NULL);
+
+   memset(&a[1], 'r', 4);
+   printf("%s\n", a);
+
+   memcpy(&a[2], a, 2);
+   printf("%s\n", a);
+
+   printf("%d\n", memcmp(a, "apple", 4) > 0);
+   printf("%d\n", memcmp(a, "grgr", 4) == 0);
+   printf("%d\n", memcmp(a, "zebra", 4) < 0);
+
+   return 0;
+}
+
+/* vim: set expandtab ts=4 sw=3 sts=3 tw=80 :*/

data/ext/tcc/tcc-0.9.26/tests/tests2/28_strings.expect

@@ -0,0 +1,19 @@
+hello
+gollo
+1
+1
+1
+5
+gollo!
+1
+1
+1
+1
+ollo!
+lo!
+1
+grrrr!
+grgrr!
+1
+1
+1

data/ext/tcc/tcc-0.9.26/tests/tests2/29_array_address.c

@@ -0,0 +1,13 @@
+#include <stdio.h>
+#include <string.h>
+
+int main()
+{
+   char a[10];
+   strcpy(a, "abcdef");
+   printf("%s\n", &a[1]);
+
+   return 0;
+}
+
+/* vim: set expandtab ts=4 sw=3 sts=3 tw=80 :*/

data/ext/tcc/tcc-0.9.26/tests/tests2/29_array_address.expect

@@ -0,0 +1 @@
+bcdef

data/ext/tcc/tcc-0.9.26/tests/tests2/30_hanoi.c

@@ -0,0 +1,122 @@
+/* example from http://barnyard.syr.edu/quickies/hanoi.c */
+
+/* hanoi.c: solves the tower of hanoi problem. (Programming exercise.) */
+/* By Terry R. McConnell (12/2/97) */
+/* Compile: cc -o hanoi hanoi.c */
+
+/* This program does no error checking. But then, if it's right, 
+   it's right ... right ? */
+
+
+/* The original towers of hanoi problem seems to have been originally posed
+   by one M. Claus in 1883. There is a popular legend that goes along with
+   it that has been often repeated and paraphrased. It goes something like this:
+   In the great temple at Benares there are 3 golden spikes. On one of them,
+   God placed 64 disks increasing in size from bottom to top, at the beginning
+   of time. Since then, and to this day, the priest on duty constantly transfers
+   disks, one at a time, in such a way that no larger disk is ever put on top
+   of a smaller one. When the disks have been transferred entirely to another
+   spike the Universe will come to an end in a large thunderclap.
+
+   This paraphrases the original legend due to DeParville, La Nature, Paris 1884,
+   Part I, 285-286. For this and further information see: Mathematical 
+   Recreations & Essays, W.W. Rouse Ball, MacMillan, NewYork, 11th Ed. 1967,
+   303-305.
+ *
+ *
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+
+#define TRUE 1
+#define FALSE 0
+
+/* This is the number of "disks" on tower A initially. Taken to be 64 in the
+ * legend. The number of moves required, in general, is 2^N - 1. For N = 64,
+ * this is 18,446,744,073,709,551,615 */
+#define N 4
+
+/* These are the three towers. For example if the state of A is 0,1,3,4, that
+ * means that there are three discs on A of sizes 1, 3, and 4. (Think of right
+ * as being the "down" direction.) */
+int A[N], B[N], C[N]; 
+
+void Hanoi(int,int*,int*,int*);
+
+/* Print the current configuration of A, B, and C to the screen */
+void PrintAll()
+{
+   int i;
+
+   printf("A: ");
+   for(i=0;i<N;i++)printf(" %d ",A[i]);
+   printf("\n");
+
+   printf("B: ");
+   for(i=0;i<N;i++)printf(" %d ",B[i]);
+   printf("\n");
+
+   printf("C: ");
+   for(i=0;i<N;i++)printf(" %d ",C[i]);
+   printf("\n");
+   printf("------------------------------------------\n");
+   return;
+}
+
+/* Move the leftmost nonzero element of source to dest, leave behind 0. */
+/* Returns the value moved (not used.) */
+int Move(int *source, int *dest)
+{
+   int i,j;
+
+   while (i<N && (source[i])==0) i++;
+   while (j<N && (dest[j])==0) j++;
+
+   dest[j-1] = source[i];
+   source[i] = 0;
+   PrintAll();       /* Print configuration after each move. */
+   return dest[j-1];
+}
+
+
+/* Moves first n nonzero numbers from source to dest using the rules of Hanoi.
+   Calls itself recursively.
+   */
+void Hanoi(int n,int *source, int *dest, int *spare)
+{
+   int i;
+   if(n==1){
+      Move(source,dest);
+      return;
+   }
+
+   Hanoi(n-1,source,spare,dest);
+   Move(source,dest);
+   Hanoi(n-1,spare,dest,source);	
+   return;
+}
+
+int main()
+{
+   int i;
+
+   /* initialize the towers */
+   for(i=0;i<N;i++)A[i]=i+1;
+   for(i=0;i<N;i++)B[i]=0;
+   for(i=0;i<N;i++)C[i]=0;
+
+   printf("Solution of Tower of Hanoi Problem with %d Disks\n\n",N);
+
+   /* Print the starting state */
+   printf("Starting state:\n");
+   PrintAll();
+   printf("\n\nSubsequent states:\n\n");
+
+   /* Do it! Use A = Source, B = Destination, C = Spare */
+   Hanoi(N,A,B,C);
+
+   return 0;
+}
+
+/* vim: set expandtab ts=4 sw=3 sts=3 tw=80 :*/

data/ext/tcc/tcc-0.9.26/tests/tests2/30_hanoi.expect

@@ -0,0 +1,71 @@
+Solution of Tower of Hanoi Problem with 4 Disks
+
+Starting state:
+A:  1  2  3  4 
+B:  0  0  0  0 
+C:  0  0  0  0 
+------------------------------------------
+
+
+Subsequent states:
+
+A:  0  2  3  4 
+B:  0  0  0  0 
+C:  0  0  0  1 
+------------------------------------------
+A:  0  0  3  4 
+B:  0  0  0  2 
+C:  0  0  0  1 
+------------------------------------------
+A:  0  0  3  4 
+B:  0  0  1  2 
+C:  0  0  0  0 
+------------------------------------------
+A:  0  0  0  4 
+B:  0  0  1  2 
+C:  0  0  0  3 
+------------------------------------------
+A:  0  0  1  4 
+B:  0  0  0  2 
+C:  0  0  0  3 
+------------------------------------------
+A:  0  0  1  4 
+B:  0  0  0  0 
+C:  0  0  2  3 
+------------------------------------------
+A:  0  0  0  4 
+B:  0  0  0  0 
+C:  0  1  2  3 
+------------------------------------------
+A:  0  0  0  0 
+B:  0  0  0  4 
+C:  0  1  2  3 
+------------------------------------------
+A:  0  0  0  0 
+B:  0  0  1  4 
+C:  0  0  2  3 
+------------------------------------------
+A:  0  0  0  2 
+B:  0  0  1  4 
+C:  0  0  0  3 
+------------------------------------------
+A:  0  0  1  2 
+B:  0  0  0  4 
+C:  0  0  0  3 
+------------------------------------------
+A:  0  0  1  2 
+B:  0  0  3  4 
+C:  0  0  0  0 
+------------------------------------------
+A:  0  0  0  2 
+B:  0  0  3  4 
+C:  0  0  0  1 
+------------------------------------------
+A:  0  0  0  0 
+B:  0  2  3  4 
+C:  0  0  0  1 
+------------------------------------------
+A:  0  0  0  0 
+B:  1  2  3  4 
+C:  0  0  0  0 
+------------------------------------------