/* --------------- */
/* --- param.c --- */
/* --------------- */

#include <stdio.h> // printf
#include <stdlib.h> // exit
#include <math.h> // sqrt

/* -------------- */
float sq_v1(float x)
/* -------------- */
{
    float y;
    y = x * x;
    return y;
}
/* ----------------------- */
void sq_v2(float x, float *y)
/* ----------------------- */
{
    *y = x * x;
}
/* ---------------- */
float sqrt_v1(float x)
/* ---------------- */
{
    // exit si x < 0
    if(x>=0.0f) {
        return sqrtf(x);
    } else {
        printf("sqrt_v1 ERROR %f < 0\n", x);
        exit(1);
    }
}
/* ------------------------ */
int sqrt_v2(float x, float *y)
/* ------------------------ */
{
    // validite du calcul via rc
    int rc; // return code
    if(x>=0.0f) {
        *y = sqrt(x);
        rc = 0; // OK
        return rc;
    } else {
        *y = 0;
        rc = 1; // erreur
        return rc;
    }
    // return rc; le return peut aussi etre a l'exterieur du if-then-else
}
/* ------------------- */
void swap(int *x, int *y)
/* ------------------- */
{
    int t;
    
     t = *x;
    *x = *y;
    *y =  t;
}
/* ---------------------------------- */
char* str_extract_v1(char* str, char *c)
/* ---------------------------------- */
{
    // lisible
    char car;
    car = *str;
    *c = car;
    str++;
    return str;
}
/* ---------------------------------------- */
char* str_extract_v1_dense(char* str, char *c)
/* ---------------------------------------- */
{
    // dense mais relativement lisible
    *c = *str++;
    return str;
}
/* ------------------------- */
char str_extract_v2(char **str)
/* ------------------------- */
{
    // long
    char car;
    char *ptr;
    ptr = *str;
    car = *ptr;
    ptr++;
    *str = ptr;
    return car;
}
/* ------------------------------- */
char str_extract_v2_dense(char **str)
/* ------------------------------- */
{
    char car = **str;
    (*str)++; // bof
    return car;
}
/* ------------ */
void test_sq(void)
/* ------------ */
{
    float x, y;
    
    x = 2;
    y = sq_v1(x);
    sq_v2(x, &y);
}
/* -------------- */
void test_sqrt(void)
/* -------------- */
{
    int rc;
    float x, y;

    x = 4;
    y = sqrt_v1(x);
    rc = sqrt_v2(x, &y);
    
    x = -4;
    y = sqrt_v1(x);
    rc = sqrt_v2(x, &y);
    // if(fc) { traitement de l'erreur }
}
/* -------------- */
void test_swap(void)
/* -------------- */
{
    int a, b;
    int *pa, *pb;
    int T[2];
    
    a = 2; b = 3;
    swap(&a, &b);
    
    pa = &a; pb = &b;
    swap(pa, pb);
    
    T[0] = 2; T[1] = 3;
    swap(&T[0], T+1); // notation pointeur a eviter
}
/* ----------------- */
void test_extract(void)
/* ----------------- */
{
    char c;
    char *str;
    char *ptr;
    str = "abcd";
    ptr = str;
    
    printf("%s = ", str);
    ptr = str_extract_v1(ptr, &c);       printf("%c + %s = ",c, ptr);
    ptr = str_extract_v1_dense(ptr, &c); printf("%c + %s = ",c, ptr);
    c = str_extract_v2(&ptr);            printf("%c + %s = ",c, ptr);
    c = str_extract_v2_dense(&ptr);      printf("%c + %s",c, ptr);
    
    free(ptr);
}
/* ------------------------- */
int* my_realloc(int *t, int *n)
/* ------------------------- */
{
    int i;
    int *u; // nouveau pointeur
    int sz1, sz2; // nouvelle taille
    
    sz1 = *n;
    // doublement de la taille et init a 1
    if(sz1 == 0) {
        sz2 = 1;
    } else {
        sz2 = 2 * sz1;
    }
    
    u = (int*) malloc(sz2 * sizeof(int));
    if(u == NULL) {
        printf("erreur alloc"); 
        exit(-1);
    }
    
    // doublement de la premiere moitie
    for(i=0; i< sz1; i++) {
        u[i] = 2 * t[i];
    }
    // init de la seconde moitie
    for(i= sz1; i<sz2; i++) {
        u[i] = i + 1;
    }
    
    *n = sz2;
    free(t);
    
    return u;
}
/* --------------------- */
void my_disp(int *t, int n)
/* --------------------- */
{
    int i;
    for(i=0; i<n; i++) {
        printf("%4d ", t[i]);
    }
    puts("");
    return;
}
/* ----------------- */
void test_realloc(void)
/* ----------------- */
{
    int i;
    int *t = NULL;
    int n = 0;
    
    for(i=0; i<10; i++) {
        t = my_realloc(t, &n);
        my_disp(t, n);
    }
}
/* ---------------------------------- */
int main (int argc, const char * argv[])
/* ---------------------------------- */
{
    //test_sq();
    //test_sqrt();
    //test_swap();
    //test_extract();
    test_realloc();
    
    return 0;
}