C useful program

Program 1

  

 #include

   #include

   #include

   #include

   union regs regs;

   void cls()

   {

               regs.h.ah = 15; int86( 0x10, &regs, &regs );

               regs.h.ah = 0; int86( 0x10, &regs, &regs );

   }

   void main()

   {

               cls();

               printf("Setting mode to 40x25 color.\n");

               printf("Press any key....\n");

               getchar();

               regs.h.ah = 0;

               regs.h.al = 1;

               int86( 0x10, &regs, &regs);

               printf("Mode has been set.\n");

   }

Program 2

#include 

#include

#include 

#include 

#include 

#define vector_ok            0

#define vector_null_error    1

#define vector_size_error    2

#define vector_alloc_error   3

struct vector 

{

    int *data;

    size_t size;

};

int create_vector(struct vector *vc, size_t num) 

{

    if (vc == NULL) 

    {

        return vector_null_error;

    }

    vc->data = 0;

    vc->size = 0;

    if (num == 0 || size_max / num < sizeof(int)) 

   {

        errno = enomem;

        return vector_size_error;

    }

    vc->data = calloc(num, sizeof(int));

    if (vc->data == NULL) 

    {

        return vector_alloc_error;

    }

    vc->size = num * sizeof(int);

    return vector_ok;

}

int grow_vector(struct vector *vc) 

{

    void *newptr = 0;

    size_t newsize;

    if (vc == NULL) 

    {

        return vector_null_error;

    }

    if (vc->size == 0 || size_max / 2 < vc->size) 

    {

        errno = enomem;

        return vector_size_error;

    }

    newsize = vc->size * 2;

    newptr = realloc(vc->data, newsize);

    if (newptr == NULL) 

    {

        return vector_alloc_error;

    }

    vc->data = newptr;

    vc->size = newsize;

    return vector_ok;

}

Program 3

#include 

#include

#include 

#define max_ref_obj 100

#define rc_error -1

struct mem_obj_t

{

    void *ptr;

    uint16_t count;

};

static struct mem_obj_t references[max_ref_obj];

static uint16_t reference_count = 0;

uint16_t create(size_t size)

{

    if (reference_count >= max_ref_obj)

        return rc_error;

    if (size)

   {

        void *ptr = calloc(1, size);

        if (ptr != NULL)

         {

            references[reference_count].ptr = ptr;

            references[reference_count].count = 0;

            return reference_count++;

        }

    }

    return rc_error;

}

void* retain(uint16_t handle)

{

    if(handle < reference_count && handle >= 0)

    {

        references[handle].count++;

        return references[handle].ptr;

    }

     else 

   {

        return NULL;

    }

}

void release(uint16_t handle)

 {

    printf("release\n");

    if(handle < reference_count && handle >= 0){

        struct mem_obj_t *object = &references[handle];

        if (object->count <= 1)

       {

            printf("released\n");

            free(object->ptr);

            reference_count--;

        } 

         else 

         {

            printf("decremented\n");

            object->count--;

        }

    }

}

Program 4

#include 

#include 

struct pool_t

{

    void *ptr;

    size_t size;

    size_t used;

};

struct pool_t* create_pool(size_t size) 

{

    struct pool_t* pool = calloc(1, sizeof(struct pool_t));

    if(pool == NULL)

        return NULL;

    if (size) 

    {

        void *mem = calloc(1, size);

        if (mem != NULL) 

        {

            pool->ptr = mem;

            pool->size = size;

            pool->used = 0;

            return pool;

        }

    }

    return NULL;

}

void* pool_alloc(struct pool_t* pool, size_t size) 

{

    if(pool == NULL)

        return NULL;

    size_t avail_size = pool->size - pool->used;

    if (size && size <= avail_size)

     {

        void *mem = pool->ptr + pool->used;

        pool->used += size;

        return mem;

    }

    return NULL;

}

void delete_pool(struct pool_t* pool) 

{

    if (pool != NULL) 

   {

        free(pool->ptr);

        free(pool);

    }

}

Program 5

#include 

#include 

#define size 8

int16_t a[size], b[size];

void addtwo()

{

    int16_t i = 0;

    while (i < size) 

   {

        a[i] = b[i] + 2;

        i++;

    }

}

int main()

{

    addtwo();

    return a[0];

}