#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include <omp.h>
#include <fenv.h>
/* Do not remove*/
/* Benoit Leveugle, CINES - ASA*/
/* This small program try to regroup most encountered bugs in HPC related work*/
/* Use -cpp for preprocessing with gcc and nothing with icc*/
 
 /* ############################################################################################
    ## Subroutines
    ############################## */
 
#ifdef leak
void function_add(void) {
 
    double *d1 = malloc(sizeof(double) * 100); // allocate an array of 100 doubles
    int i;
    for(i=0;i<100;i++)
    {
       d1[i]=d1[i]+1.0;
    }
    // forget to free the d1 memory which was allocated inside a function
}
#endif
 
 
main()
{
feenableexcept(FE_DIVBYZERO| FE_INVALID|FE_OVERFLOW);
#ifdef hello
    // hello world
    printf("Hello World\n");
#endif
 
 
 
 
 /* ############################################################################################
    ## Floating point exceptions
    ############################## */
 
#ifdef divzero 
// divided by zero, fpe
 
 double d1,d2,d3;
 
 d2 = 10.0;
 d3 = 0.0;
 d1 = d2 / d3;
 printf(" %f %f %f \n",d1,d2,d3);
 
#endif
 
#ifdef nan 
// generate a nan, fpe
 
 double d1,d2;
 
 d2 = 10.0;
 d1 = acos(d2);
 printf(" %f %f \n",d1,d2);
 
#endif
 
#ifdef overflow 
// generate an overflow, same as underflow, fpe
 
 double d1,d2;
 
 d2 = 10e10;
 d1 = exp(d2);
 printf(" %f %f \n",d1,d2);
 
#endif
 
 
 
 
 /* ############################################################################################
    ## uninitialized
    ############################## */
 
#ifdef uninitstatic
// use a non initialized value, static
 
 double d1,d2;
 
 d1 = d2*10.0;
 printf(" %f %f \n",d1,d2);
 
#endif
 
#ifdef uninitdynamic
// use a non initialized value, dynamic
 
 double *d1 = malloc(sizeof(double)*10);
 double *d2 = malloc(sizeof(double)*10);
 
 d1[3] = d2[4]*10.0;
 printf(" %f %f \n",d1[3],d2[4]);
 free(d1);
 free(d2);
 
#endif
 
#ifdef uninitalloc
// use a non initialized value, not allocated
 
 double *d1 = malloc(sizeof(double)*10);
 double *d2;
 
 d1[3] = d2[4]*10.0;
 printf(" %f %f \n",d1[3],d2[4]);
 free(d1);
 
#endif
 
 
 
 
 /* ############################################################################################
    ## allocations
    ############################## */
 
#ifdef unalloc
// try do free an non allocated variable
 
 double *d1;
 double *d2;
 
 free(d1);
 
#endif
 
#ifdef allocalloc
// try do allocate an already allocated variable
 
 double *d1;
 d1 = malloc(sizeof(double)*10);
 d1 = malloc(sizeof(double)*100);
 free(d1);
 
#endif
 
#ifdef nonfree
// detect not freed memory
 
 double *d1 = malloc(sizeof(double)*10);
 double *d2 = malloc(sizeof(double)*100);
 int i;
 for(i=0;i<100;i++)
 {
   d2[i] = 100.0;
 }
 d1[3] = d2[4]*10.0;
 printf(" %f %f \n",d1[3],d2[4]);
 
 free(d1);
 
#endif
 
 
 
 
 /* ############################################################################################
    ## arrays
    ############################## */
 
#ifdef outofbound
// out of array bounds, read or write
 
 double *d1 = malloc(sizeof(double)*10);
 int i;
 for(i=0;i<10;i++)
 {
   d1[i] = 10.0;
 }
 printf(" %f %f \n",d1[1],d1[10]);
 free(d1);
 
#endif
 
 
 
 
 /* ############################################################################################
    ## io
    ############################## */
 
#ifdef ionotopen
 
 char str1[10], str2[10], str3[10];
 int year;
 FILE * fp;
 
 fp = fopen ("file.txt", "w+"); // not a good practice, prefer w and r, and play with r, r+, w, w+, a, a+, x, x+ to secure file operations
 
 if (fp == NULL)
 {
    printf("Error opening file!\n");
    exit(1);
 }
 
 fputs("We are in 2014 \n", fp);
 
 rewind(fp);
 if( fscanf(fp, "%s %s %s %d", str1, str2, str3, &year) != EOF)
 {
 printf("Read String1 |%s|\n", str1 );
 printf("Read String2 |%s|\n", str2 );
 printf("Read String3 |%s|\n", str3 );
 printf("Read Integer |%d|\n", year );
 }
 else
 {
 printf("Could not read file");
 }
 
 fclose(fp);
 
#endif
 
 
 
 
 /* ############################################################################################
    ## memory leak
    ############################## */
 
#ifdef leak
 
 function_add();
 // the pointer 'd1' no longer exists, but the memory is still allocated. Leak.
 function_add();
 
#endif
 
 
 
 
 /* ############################################################################################
    ## stack overflow
    ############################## */
 
#ifdef stackover
 double U1[1000000];
 
  #pragma omp parallel default(none) private(U1)
  {
     U1[0]=1.0;
     printf("Hello World\n");
  }
 
#endif
 
 
 
 
 /* ############################################################################################
    ## buffer overflow
    ############################## */
 
#ifdef bufferover
 
 char           A[8] = {};
 unsigned short B    = 1979;
 
 strcpy(A, "excessive"); // 'excessiv' go to A, remaining 'e' goes to B which follows in stack memory : buffer overflow
 
#endif
 
 printf("\nEnd\n");
 
}