move to cmake compile structure

Makefile

@@ -1,47 +0,0 @@
-.PHONY = all pre testfiles bigfiles
-SOURCES = $(wildcard *.c)
-BINARIES = $(SOURCES:%.c=%)
-EXECUTABLES= $(addprefix bin/,${BINARIES})
-all: pre $(EXECUTABLES) huffman/bin/huffman testfiles
-
-big: all bigfiles
-pre:
-		@mkdir -p bin huffman/bin huffman/testfiles
-
-clean:
-		rm -rvf bin huffman/testfiles huffman/bin
-
-huffman/bin/huffman: huffman/huffman.c
-		$(CC) $(CFLAGS) -o $@ $< -lm
-
-# TODO convert this phony target into multiple smaller file targets
-testfiles:
-		@dd if=/dev/urandom of=huffman/testfiles/1K-random.img count=1KiB
-		@dd if=/dev/urandom of=huffman/testfiles/10K-random.img count=10KiB
-		@dd if=/dev/urandom of=huffman/testfiles/100K-random.img count=100KiB
-		@dd if=/dev/urandom of=huffman/testfiles/1M-random.img count=1MiB
-		@dd if=/dev/urandom of=huffman/testfiles/10M-random.img count=10MiB
-		@dd if=/dev/zero of=huffman/testfiles/1K-zero.img count=1KiB
-		@dd if=/dev/zero of=huffman/testfiles/10K-zero.img count=10KiB
-		@dd if=/dev/zero of=huffman/testfiles/100K-zero.img count=100KiB
-		@dd if=/dev/zero of=huffman/testfiles/1M-zero.img count=1MiB
-		@dd if=/dev/zero of=huffman/testfiles/10M-zero.img count=10MiB
-		@echo -e "Wer\ndas\nliest\nist\ndoof\n" > huffman/testfiles/tiny.txt
-		@yes 'SAFJALJ AF OIAIFOsdp' | head -c 100KB > huffman/testfiles/small.txt
-		@yes 'lslfkpoipop iipfiasp' | head -c 1MB > huffman/testfiles/mid.txt
-		
-
-# TODO convert this phony target into multiple smaller file targets
-bigfiles:
-		@echo "Building some bigger testfiles, this might take a while and draw some performance"
-		@dd if=/dev/urandom of=huffman/testfiles/100M-random.img count=100MiB
-		@dd if=/dev/zero of=huffman/testfiles/100M-zero.img count=100MiB
-		@dd if=/dev/urandom of=huffman/testfiles/1G-random.img count=1GiB
-		@dd if=/dev/urandom of=huffman/testfiles/10G-random.img count=10GiB
-		@dd if=/dev/zero of=huffman/testfiles/1G-zero.img count=1GiB
-		@dd if=/dev/zero of=huffman/testfiles/10G-zero.img count=10GiB
-		@yes 'a sla d JK J Kkl' | head -c 100MB > huffman/testfiles/big.txt
-		@yes ' POP OPO )()( as' | head -c 1G > huffman/testfiles/huge.txt
-
-$(EXECUTABLES): $(SOURCES)
-		$(CC) $(CFLAGS) -o $@ $< -lm

src/abc.c

@@ -0,0 +1,27 @@
+#include <stdio.h>
+#include <math.h>
+#include <complex.h>
+#include <stdlib.h>
+
+int main(int argc, char **argv){
+
+    if(argc<3){
+	printf("not enough args! Ex: ./abc 12 -3 5\n");
+	exit(EXIT_FAILURE);
+    }
+    double a = atoi(argv[1]);
+    double b = atoi(argv[2]);
+    double c = atoi(argv[3]);
+
+    printf("(%f)x²+(%f)x+(%f)=0\n", a, b, c);
+    double l1 = 0, l2 = 0;
+    double cl1 = 0, cl2 = 0;
+    l1=(-b + sqrt((b*b)-(4*a*c)))/(2*a);
+    l2=(-b - sqrt((b*b)-(4*a*c)))/(2*a);
+    cl1=(-b + csqrt((b*b)-(4*a*c)))/(2*a);
+    cl2=(-b - csqrt((b*b)-(4*a*c)))/(2*a);
+    printf("(-%.0f (+-) sqrt[(%.0f²)-(4*%.0f*%.0f)])/2*%.0f\n", b, b, a, c, a);
+    printf("x1=%f	x2=%f\n", l1, l2);
+    printf("(complex mode)\nx1=%fi\tx2=%fi\n", cl1, cl2);
+    return 0;
+}

src/adder.c

@@ -0,0 +1,9 @@
+#include <stdio.h>
+
+int main() {
+	int a, b;
+	printf("Please input two integers to be added.\n");
+	scanf("%d %d", &a, &b);
+	printf("%d + %d = %d\n", a, b, a+b);
+	return 0;
+}

src/args.c

@@ -0,0 +1,15 @@
+#include <stdio.h>
+
+int main(int argc, char* argv[]){
+
+    if(argc==1){
+	printf("Recieved only one argument, idiot");
+	return 1;
+    }
+
+    for(int i = 0; i < argc+1; i++){
+	printf("%d.	[%s]\n", i+1, argv[i]);
+    }
+
+    return 0;
+}

src/arrToBin.c

@@ -0,0 +1,28 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+int main(){
+    // input as single int, output as array of ints with only 0 and 1s 
+
+    char str_i[20];
+    int i;
+    
+    fgets(str_i, 20, stdin);
+    i = strtol(str_i, NULL, 0);
+    printf("%d", i);
+
+    int bin[16] = { -1 };
+    int b;
+
+    printf("[CONTROL]as hex %x\n", i);
+    for(int j = 16; j>0; j--){
+        b = i%2;
+        i /= 2;
+        bin[i] = b;
+    }
+    for(int j = 0; j < 16; j++){
+            printf("%d", bin[j]);
+    }
+    printf("\n");
+    return 0;
+}

src/ascii.c

@@ -0,0 +1,8 @@
+#include <stdio.h>
+
+int main(){
+    for(int i=0; i<256; i++){
+	printf("(dec)%d\t(hex)0x%02x\t(char)%c\t\n",i,i,i);
+    }
+    return 0;
+}

src/calculator.c

@@ -0,0 +1,49 @@
+#include <stdio.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+double factorial(double i) {
+    if(i <= 1) {
+	return 1;
+    }
+    return i * factorial(i - 1);
+}
+
+double power(double a, double b) {
+    double result = a;
+    for(int i=0;i<b;i++){
+	result*=a;
+    }
+    return result;
+}
+
+int main(int argc, char **argv){
+
+    // inputs
+    uint32_t a, b;
+    char op;
+    while(1) {
+	printf("\nPlease input the first number.\n");
+	fflush(stdin);
+    	scanf("%d", &a);
+    	printf("Please input the second number.\n");
+	fflush(stdin);
+    	scanf("%d", &b);
+    	printf("Please select an operation. ( + - * / ^ ! ), e to exit.\n");
+	fflush(stdin);
+    	scanf(" %c", &op);	//The %c conversion specifier won't automatically skip any leading whitespace
+    	
+    	// calculate stuff.
+    	switch(op) {
+    	    case '+': printf("%d + %d = %d\n", a, b, a+b); break;
+    	    case '-': printf("%d - %d = %d\n", a, b, a-b); break;
+    	    case '*': printf("%d * %d = %d\n", a, b, a*b); break;
+    	    case '/': printf("%d / %d = %f\n", a, b, (double)a/(double)b); break;
+    	    case '^': printf("%d^%d = %f\n", a, b, power((double)a,(double)b)); break;
+    	    case '!': printf("%d! = %f\n", a, factorial((double)a)); break;
+	    case 'e': printf("exiting...\n"); return 0;
+    	    //case '%': printf("%d % %d = %d\n", a, b, a%b); break; // idk weird outputs.
+    	    default: printf("no operation recognized.\n"); return 1;
+    	}
+    }
+}

src/callreference.c

@@ -0,0 +1,22 @@
+#include <stdio.h>
+
+int* ref(int *i, int* j, int* result){
+    *result = *i + *j;
+    return result;
+}
+    
+int val(int a, int b){
+    return a+b;
+}
+
+int main(){
+
+    int x = 1000;
+    int y = 337;
+    int z;
+    printf("given: %d\n", x);
+    printf("reference: %d\n", *ref(&x, &y, &z));
+    printf("value: %d\n", val(x, y));
+
+    return 0;
+}

src/complex.c

@@ -0,0 +1,83 @@
+#include <stdio.h>
+
+typedef struct
+{
+    float real;
+    float imaginary;
+}complex;
+
+complex assignComplex(){
+    float r, i;
+    scanf("%f", &r);
+    scanf("%f", &i);
+    complex c;
+    c.real = r;
+    c.imaginary = i;
+    return c;
+}
+
+void addComplex() {
+    printf("First complex\n");
+    complex a = assignComplex(); 
+    printf("Second complex\n");
+    complex b = assignComplex(); 
+
+    complex r;
+    r.real = a.real + b.real;
+    r.imaginary = a.imaginary + b.imaginary;
+    printf("Result: %f+%fi\n", r.real, r.imaginary);
+}
+
+void subComplex() {
+    printf("First complex\n");
+    complex a = assignComplex(); 
+    printf("Second complex\n");
+    complex b = assignComplex(); 
+
+    complex r;
+    r.real = a.real - b.real;
+    r.imaginary = a.imaginary - b.imaginary;
+    printf("Result: %f+%fi\n", r.real, r.imaginary);
+}
+
+void mulComplex() {
+    printf("First complex\n");
+    complex a = assignComplex(); 
+    printf("Second complex\n");
+    complex b = assignComplex(); 
+
+    complex r;
+    r.real = a.real * b.real;
+    r.imaginary = a.imaginary * b.imaginary;
+    printf("Result: %f+%fi\n", r.real, r.imaginary);
+}
+
+void divComplex() {
+    printf("First complex\n");
+    complex a = assignComplex(); 
+    printf("Second complex\n");
+    complex b = assignComplex(); 
+
+    complex r;
+    r.real = a.real / b.real;
+    r.imaginary = a.imaginary / b.imaginary;
+    printf("Result: %f+%fi\n", r.real, r.imaginary);
+}
+
+int main() {
+    printf("Usage:\n\toperations: + - * /\n\tquit: q\n");
+
+    char in;
+    while(1){
+
+        in = getchar();
+        switch(in){
+            case 'q': return 0;
+            case '+': addComplex(); break;
+            case '-': subComplex(); break;
+            case '*': mulComplex(); break;
+            case '/': divComplex(); break;
+            default: printf("kaputt\n"); break;
+        }
+    }
+}

src/dividableBy7.c

@@ -0,0 +1,27 @@
+/*
+ * lower and upper end as user input
+ * use a for loop to output all numbers for which 7|x is true.
+ */
+
+#include <stdio.h>
+
+int main() {
+    
+    int a,b;
+    printf("input lower end:\n");
+    fflush(stdin);
+    scanf("%d",&a);
+    printf("input upper end:\n");
+    fflush(stdin);
+    scanf("%d",&b);
+
+    printf("inputs: %d %d\n", a, b);
+    for(int i=a; i<=b; i++){
+	if(i%7==0)
+	    printf("%d ", i);
+	if(i==b)
+	    printf("\n");
+    }
+    
+    return 0;
+}

src/echo.c

@@ -0,0 +1,17 @@
+#include <stdio.h>
+
+int main() {
+	char s[100];
+    //gets(s);
+    /*
+     * Never use gets().  Because it is impossible to tell without knowing the data in advance how many characters gets() will read,  and  be‐
+     * cause gets() will continue to store characters past the end of the buffer, it is extremely dangerous to use.  It has been used to break
+     * computer security.  Use fgets() instead.
+     *
+     * For more information, see CWE-242 (aka "Use of Inherently Dangerous Function") at http://cwe.mitre.org/data/definitions/242.html
+     *
+     */
+    fgets(s, sizeof(s), stdin);
+	printf("%s\n", s);
+	return 0;
+}

src/echochar.c

@@ -0,0 +1,8 @@
+#include <stdio.h>
+
+int main() {
+	
+	char a = getchar();
+	printf("%c", a);
+	return 0;
+}

src/euler.c

@@ -0,0 +1,50 @@
+#include <stdio.h>
+
+#include <stdio.h>
+#include <stdlib.h>
+
+// range of unsigned long long is:
+// 18.446.744.073.709.551.615
+// maximum factorial with this is 65!
+// Double goes up to 170!
+double factorial(double i) {
+
+   if(i <= 1) {
+      return 1;
+   }
+   return i * factorial(i - 1);
+}
+
+ double factorialFor(double given){
+    double p = 1;
+
+    // someone said i need 2 for loops. Totally wrong?
+    for(int j=1;j<given;j++){
+        
+        p *= j;
+        //printf("[DEBUG]p is %f, j is %d\n", p, j);
+    }
+    return given * p;
+}
+
+double euler(int k) {
+    return 1/factorial(k);
+}
+int main(int argc, char *argv[]){
+    double res = 0, lres = 0;
+    int k = 0;
+    int end = 0;
+    while(!end){
+	res += euler(k);
+	printf("%f, %f\n", res, lres);
+	if(res==lres)
+	    end = 1;
+	else { 
+	    lres = res;
+	}
+	k++;
+    }
+    printf("calculated eulers number as %f\n", res);
+    return 0;
+}
+

src/factorial.c

@@ -0,0 +1,39 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+// range of unsigned long long is:
+// 18.446.744.073.709.551.615
+// maximum factorial with this is 65!
+// Double goes up to 170!
+double factorial(double i) {
+
+   if(i <= 1) {
+      return 1;
+   }
+   return i * factorial(i - 1);
+}
+
+ double factorialFor(double given){
+    double p = 1;
+
+    // someone said i need 2 for loops. Totally wrong?
+    for(int j=1;j<given;j++){
+        
+        p *= j;
+        //printf("[DEBUG]p is %f, j is %d\n", p, j);
+    }
+    return given * p;
+}
+
+int main(int argc, char *argv[]){
+    if(argc<=1) {
+        printf("You did not feed me arguments, I will die now :( gimme ints");
+	return 1;
+    }  //otherwise continue on our merry way....
+
+    double num = atoi(argv[1]);
+    printf("the factorial of the given input calculated by a recursive algorithm is: %.0f\n", factorial(num));
+    printf("the factorial of the given input calculated by a nonrecursive algorithm is: %.0f\n", factorialFor(num));
+    return 0;
+}
+

src/fail.c

@@ -0,0 +1,10 @@
+#include <stdio.h>
+
+/*
+ * This program has the purpose of returning a -1 value, indicating the shell that something has gone wrong
+ * while the program was running.
+ */
+
+int main(){
+    return -1;
+}

src/fread.c

@@ -0,0 +1,24 @@
+#include <stdio.h>
+#include <string.h>
+
+int main () {
+   FILE *fp;
+   char c[] = "this is tutorialspoint";
+   char buffer[100];
+
+   /* Open file for both reading and writing */
+   fp = fopen("file.txt", "w+");
+
+   /* Write data to the file */
+   fwrite(c, strlen(c) + 1, 1, fp);
+
+   /* Seek to the beginning of the file */
+   fseek(fp, 0, SEEK_SET);
+
+   /* Read and display data */
+   fread(buffer, strlen(c)+1, 1, fp);
+   printf("%s\n", buffer);
+   fclose(fp);
+   
+   return(0);
+}

src/hello-world.c

@@ -0,0 +1,6 @@
+#include <stdio.h>
+
+int main() {
+	printf("Hello world!\n");
+	return 0;
+}

src/options.c

@@ -0,0 +1,26 @@
+#include <stdbool.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+
+int main(int argc, char *argv[])
+{
+    bool isCaseInsensitive = false;
+    int opt;
+    enum { CHARACTER_MODE, WORD_MODE, LINE_MODE } mode = CHARACTER_MODE;
+
+    while ((opt = getopt(argc, argv, "ilw")) != -1) {
+        switch (opt) {
+        case 'i': isCaseInsensitive = true; break;
+        case 'l': mode = LINE_MODE; break;
+        case 'w': mode = WORD_MODE; break;
+        default:
+            fprintf(stderr, "Usage: %s [-ilw] [file...]\n", argv[0]);
+            exit(EXIT_FAILURE);
+        }
+    }
+
+    // Now optind (declared extern int by <unistd.h>) is the index of the first non-option argument.
+    // If it is >= argc, there were no non-option arguments.
+
+}

src/pointer-arithmetic.c

@@ -0,0 +1,9 @@
+#include <stdio.h>
+
+int main() {
+    int a[5] = {22, 33, 44, 55, 66};
+    int *ptr = NULL;
+    ptr = a;  /* point to the first array element */
+    for(int i = 0; i < 50; i++) {
+    printf(" value:0x%-10x\tor 0d%-16d\tAdress:%-8x\n", *(ptr+i), *(ptr+i), ptr+i);  /* 33 */
+}}

src/pointermagic.c

@@ -0,0 +1,19 @@
+#include <stdio.h>
+
+void printLoc(int y) {
+    printf("Address of y is %x\n", &y);
+}
+
+void printPointerLoc(int *x) {
+    printf("Adress of x is %x\n", &x);
+    printf("Adress the x pointer points to is %x\n", x);
+    printf("Adress of whatever *x is is %x\n", *x);
+}
+
+int main() {
+    int a = 0xAAAA;
+    printf("Address of a is %x\n", &a);
+    printLoc(a);
+    printPointerLoc(&a);
+    return 0;
+}

src/primenumbers.c

@@ -0,0 +1,43 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+int main(int argc, char** argv) {
+    int maxPrime = atoi(argv[1]);
+
+    int *arr1 = malloc(sizeof(int)*maxPrime);
+    if(arr1==NULL)
+        return -1;
+    for(int i=0; i<maxPrime; i++) {
+        arr1[i]=i+2;
+    }
+
+    int p = 2;
+
+    for(int i=1; i<maxPrime; i++) {
+        for(int j=1; j<maxPrime; j++) {
+            if((arr1[j]%p==0)&&(arr1[j]>0)&&(arr1[j]!=p))
+                arr1[j]=-1;
+        }
+        // get next prime in arr
+        // FIXME
+        p = arr1[i];
+        for(int l=0;l<512;l++){
+            if(p>0)
+                break;
+            else {
+                p = arr1[i+l]; 
+            }
+        }
+        for(int l=0;l<maxPrime;l++){
+        }
+    }
+    printf("\n");
+    printf("\n");
+    for(int i=0;i<maxPrime;i++){
+        if(arr1[i]>0)
+            printf("%d ", arr1[i]);
+    }
+    free(arr1);
+    printf("\n");
+    return 0;
+}

src/quersumme.c

@@ -0,0 +1,30 @@
+#include <stdio.h>
+int main() {
+    int a, digits = 0, b = 0;
+    printf("input a number for calculation\n");
+    fflush(stdin);
+    scanf("%d",&a);
+
+    int digit[128];
+
+    // look out for wrong order
+    for(int i=0; i<128; i++) {
+	digit[i] = a % 10;
+	if(a>0)
+	    a = a / 10;
+	else {
+	    if(digits==-1)
+		digits = i;
+	    digit[i] = -1;
+	}
+	//printf("%d. digit is: %d\n", i, digit[i]);
+    }
+
+    // array is in wrong order, but who cares for the quersumme
+    for(int i=0; i<128; i++){
+	if(digit[i]>0)
+	    b += digit[i];
+    }
+    printf("quersumme is: %d\n", b);
+    return 0;
+}

src/readfile.c

@@ -0,0 +1,23 @@
+#include <stdlib.h>
+#include <stdio.h>
+ 
+int main(void)
+{
+   char filename[] = "file.txt";
+   char buf[2];
+   FILE *fp;
+    
+   if ((fp = fopen(filename, "rb")) == NULL)
+   {
+      printf("Unable to open file: %s\n", filename);
+      return EXIT_FAILURE;
+   }
+    
+   if (fread(buf, 1, 2, fp) == 2)
+   {
+      printf("%02x %02x\n", (int) buf[0], (int) buf[1]);
+   }
+    
+   fclose(fp);
+   return 0;
+}

src/redefinition-if.c

@@ -0,0 +1,8 @@
+#include <stdio.h>
+int main() {
+    int a;
+    if(1){
+	int a;	// works, this a is only in scope of the if statement.
+    }
+    return 0;
+}

src/redefinition.c

@@ -0,0 +1,7 @@
+#include <stdio.h>
+int a = 1;
+int main() {
+    int a = 2;
+    printf("%d\n", a); // local overrides global
+    return 0;
+}

src/return-specified.c

@@ -0,0 +1,15 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+/*
+ * This program takes the given argument and returns it as an integer.
+ * It might be useful to test a shell.
+ */
+
+int main(int argc, char** argv){
+    if(argc<2){
+        printf("No argument given.\n");
+        return -1;
+    }
+    return atoi(argv[1]);
+}

src/scanf-test.c

@@ -0,0 +1,11 @@
+#include <stdio.h>
+
+int main() {
+    int a;
+    float f;
+    char s[20];
+    printf("input an integer, a float, then a string.\n");
+    scanf("%d %f %s", &a, &f, s);
+    printf("%d %f %s\n", a, f, s);
+    return 0;
+}

src/scnaf-hex-test.c

@@ -0,0 +1,8 @@
+#include <stdio.h>
+
+int main() {
+    int a;
+    scanf("%x", &a);
+    printf("hex: %x dec: %d\n", a, a);
+    return 0;
+    }

src/signed-to-unsigned.c

@@ -0,0 +1,6 @@
+#include <stdio.h>
+
+int main() {
+    signed int a = -1;
+    printf("%u\n",a); // no need to type cast. %u interprets given bytes of type unsigned int regardless of the datatype. truly low level
+    }

src/sizeofs.c

@@ -0,0 +1,10 @@
+#include <stdio.h>
+
+int main() {
+    printf("int: %ld \n", sizeof(int));
+    printf("float: %ld \n", sizeof(float));
+    printf("double: %ld \n", sizeof(double));
+    printf("char: %ld \n", sizeof(char));
+
+    return 0;
+}

src/structdump.c

@@ -0,0 +1,42 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+struct a {
+    int a;
+    char str[30];
+};
+
+/*
+ * give an argument to keep the file /tmp/structdump
+ * like this: bin/dump aaa
+ */
+
+int main(int argc, char** argv){
+    struct a* mystruct = malloc(sizeof(struct a));
+    if(mystruct == NULL){
+        printf("malloc for 1st struct failed!\n");
+        return 1;
+    }
+    mystruct->a = 12;
+    char s[30] = "Wer das liest ist doof";
+    strcpy(mystruct->str, s);
+    FILE* fptr = fopen("/tmp/structdump", "wb");
+    fwrite(mystruct, sizeof(struct a), 1, fptr);
+    fclose(fptr);
+    free(mystruct);
+
+    fptr = fopen("/tmp/structdump", "rb"); 
+    mystruct = malloc(sizeof(struct a));
+    if(mystruct == NULL){
+        printf("malloc for 2nd struct failed!\n");
+        return 1;
+    }
+    fread(mystruct, sizeof(struct a), 1, fptr); 
+    printf("mystruct->a: %d\nmystruct->str: \"%s\"\n", mystruct->a, mystruct->str);   // SIGSEV
+    free(mystruct);
+    fclose(fptr);
+    if(argc<2)
+        remove("/tmp/structdump");
+    return 0;
+}

src/success.c

@@ -0,0 +1,10 @@
+#include <stdio.h>
+
+/*
+ * This program has the purpose of returning a 0 value, indicating to the shell that the program was
+ * executed successfully.
+ */
+
+int main(){
+    return 0;
+}

src/sum.c

@@ -0,0 +1,11 @@
+#include <stdio.h>
+
+int main(){
+
+    int result = 0;
+    for (int i = 1; i < 101; i++){
+	result+=i;
+    }
+    printf("sum of 1 up to 100 is: %d\n", result);
+    return 0;
+}

src/tabtest.c

@@ -0,0 +1,8 @@
+#include <stdio.h>
+
+int main() {
+    printf("horizontal\ttab\n");
+    printf("vertical%ctab\n", 11);
+    printf("reference line\n");
+    return 0;
+}

src/umlaut.c

@@ -0,0 +1,3 @@
+#include <stdio.h>
+int main() { return 0; }
+int zähler() { return 0; } // umlaute is an unknown char for gcc

src/unary-double-not.c

@@ -0,0 +1,6 @@
+#include <stdio.h>
+
+int main(){
+    printf("%d\n",!!42);
+    return 0;
+}

src/warning.c

@@ -0,0 +1,15 @@
+#include <stdio.h>
+
+int main(){
+    char s[2];
+    /*
+     * The following line of code is unsafe. It writes up to 10 bytes into the char array 's', which is only
+     * 2 Bytes big. A Buffer Overflow can happen. I have chosen to keep that line, because i wanted a source
+     * file that produces a compiler warning when it is compiled. That is the true purpose of this file.
+     *
+     * a safe alternative would be: fgets(s, 2, stdin);
+     */
+    fgets(s, 10, stdin);    // UNSAFE 
+    printf("%s\n",s);
+    return 0;
+}