/* 
 * Diagnostics `<assert.h>' : Defines the `assert' and 
 * `static_assert' macros. 
 */

#ifndef H_LP_ASSERT_20120801120125
# define H_LP_ASSERT_20120801120125

# ifdef NDEBUG

/*
 * It refers to another macro, `NDEBUG', which is not defined by 
 * `<assert.h>'. If `NDEBUG' is defined as a macro name at the point
 * in the source file where `<assert.h>' is included, the assert 
 * macro is defined simply as `#define assert(ignore) ((void)0)'. The
 * `assert' macro is redefined according to the current state of 
 * `NDEBUG' each time that `<assert.h>' is included.
 */
#  define assert(ignore) ((void)0)
# else

_Noreturn extern void __assert_failure(const char *, const char *, 
				       const char *, int);

/*
 * The `assert' macro puts diagnostic test into programs; it expands
 * to a `void' expression. When it is executed, if `expression' 
 * (which shall have a scalar type) is false (that is, compares equal
 * to 0), the `assert' macro writes information about the particular
 * call that failed (including the text of the argument, the name of 
 * the source file, the source line number, and the name of the 
 * enclosing function - the latter are respectively the values of the
 * preprocessing macros  `__FILE__' and `__LINE__' and of the 
 * identifier `__func__') on ne standard error stream in a 
 * implementation-defined format. It then calls the `abort' function.
 * The `assert' macro returns no value.
 */
#  define assert(expression) 					    \
	(void)(((expression) == 0) ?                                \
		__assert_failure(#expression, __func__, __FILE__,   \
			         __LINE__) : 0)

# endif /* NDEBUG */

/* The macro `static_assert' expands to `_Static_assert'. */
# define static_assert _Static_assert

#endif /* H_LP_ASSERT_20120801120125 */

#include <stdio.h>
#include <stdlib.h>
#include "assert.h"

#ifndef NDEBUG

_Noreturn void
__assert_failure(const char *expression, const char *func, 
	         const char *file, int line)
{
	fprintf(stderr, "Assertion failed: %s, function %s, " 
		        "file %s, line %d.\n", 
		         expression, func, file, line);
	fflush(stderr);
	abort();
}

#endif /* NDEBUG */

#ifndef MY_STRING_H
#define MY_STRING_H

char * my_strcpy(char * copie, const char * origine);
char * my_strncpy(char * dst, const char * src, int n);
size_t my_strlen(const char * str);
const char * my_strchr(const char * str, int car);
char * my_strcat(char * dest, const char * orig);
int my_strcmp(const char * str1, const char *str2);
int my_strncmp(const char * str1, const char *str2, int n);
char * my_strstr (const char * str, const char * unstr);
char * my_strpbrk(const char * str, const char * c);

#endif

#include <stddef.h>
#include "my_string.h"

char * my_strcpy(char * dst, const char * src)
{
    size_t i;

    for (i = 0; (dst[i] = src[i]); i++);
    return dst;
}

char * my_strncpy(char * dst, const char * src, int n)
{
    size_t i;

    for (i = 0; (dst[i] = src[i]) && i < n; i++);

    dst[i] = '\0';

    return dst;
}

size_t my_strlen(const char * str)
{
    size_t lg = 0;

    while(str[lg])
        lg++;

    return lg;
}

const char * my_strchr(const char * str, int car)
{
    while(*str)
    {
        if (*str == car || *str == '\0')
            return str;

        else
            str++;
    }

    return NULL;
}

char * my_strcat(char * dest, const char * orig)
{
    my_strcpy(dest + my_strlen(dest), orig);

    return dest;
}

char * my_strncat(char * dest, const char * orig, int n)
{
    my_strncpy(dest + my_strlen(dest), orig, n);

    return dest;
}

int my_strcmp(const char * str1, const char *str2)
{
    while(*str1 == *str2)
    {
        if (*str1 == 0)
            return 0;

        str1++;
        str2++;
    }

    return *str1 < *str2 ? -1 : 1;
}

int my_strncmp(const char * str1, const char *str2, int n)
{
    while(n--)
    {
        if (*str1 == 0 || *str1 != *str2)
            return *str1 < *str2 ? -1 : 1;

        str1++;
        str2++;
    }

    return 0;
}

char * my_strstr (const char * str, const char * unstr)
{
    while(*str)
    {
        if (my_strncmp(str, unstr, my_strlen(unstr)) == 0)
            return (char*)str;

        str++;
    }

    return NULL;
}

char * my_strpbrk(const char * str, const char * c)
{
    size_t i, len = my_strlen(c);

    while(*str)
    {
        for (i = 0; i < len; i++)
        {
            if(c[i] == *str)
                return (char*)str;
        }

        str++;
    }

    return NULL;
}

#ifndef __STRING_H_HO
#define __STRING_H_HO

#include <stddef.h>
#include <wchar.h>

/* Set the first num bytes of the block memory pointed by ptr to the specified value (interpreted as an unsigned char). 

Return value is ptr */
void *memset (void *ptr, int value, size_t num);
wchar_t *wmemset (wchar_t *ptr, wchar_t value, size_t num);

/* Copy the first num bytes of the block memory pointed by source to the block memory pointed by destination. Block memory must not overleap. 

Return value is destination */
void *memcpy (void *dest, const void *src, size_t num);
wchar_t *wmemcpy (wchar_t *dest, const wchar_t *src, size_t num);

/* Move the first num bytes of the block memory pointed by source to the block memory pointed by destination. Block memory may overleap. 

Return value is source */
void *memmove (void *dest, const void *src, size_t num);
wchar_t *wmemmove (wchar_t *dest, const wchar_t *src, size_t num);

#endif

#include "libc.h"

void *memset (void *ptr, int value, size_t num) {
    unsigned char *ptrc = ptr ;
    for (; num > 0 ; num--, ptrc++) {
	*ptrc = (unsigned char)value ;
    }
    return ptr ;
}

wchar_t *wmemset (wchar_t *ptr, wchar_t value, size_t num) {
    for (; num > 0 ; num--, ptr++) {
	*ptr = (unsigned char)value ;
    }
    return ptr ;
}


void *memcpy (void *dest, const void *src, size_t num) {
    unsigned char *destc = dest ;
    const unsigned char *srcc = src ;
    for (; num > 0; num--, destc++, srcc++) {
	*destc = *srcc ;
    }
    return dest ;
}

wchar_t *wmemcpy (wchar_t *dest, const wchar_t *src, size_t num) {
    for (; num > 0; num--, dest++, src++) {
	*dest = *src ;
    }
    return dest ;
}

void *memmove (void *dest, const void *src, size_t num) {
    unsigned char *destc = dest;
    const unsigned char *srcc = src ;
    if (dest <= src) {
	for (; num > 0; num--, destc++, srcc++) {
	    *destc = *srcc ;
	}
    }
    else {
	srcc += (num - 1);
	destc += (num - 1);
	for (; num > 0; num--, destc--, srcc--) {
	    *destc = *srcc ;
	}
    }
    return dest ;
}

wchar_t *wmemmove (wchar_t *dest, const wchar_t *src, size_t num) {
    if (dest <= src) {
	for (; num > 0; num--, dest++, src++) {
	    *dest = *src ;
	}
    }
    else {
	src += (num - 1);
	dest += (num - 1);
	for (; num > 0; num--, dest--, src--) {
	    *dest = *src ;
	}
    }
    return dest ;
}