Simple C to Stack by using Doubly-Linked List

/*
 * File name: m_stack.h
 * Author: Seree Rakwong
 * Date: 16-SEP-2013
 *
 */

#ifndef _MSTACK_H_
#define _MSTACK_H_

#include "m_list.h"

#ifdef __cplusplus
extern "C" {
#endif

typedef void* mstack_t;
typedef void* mstack_item_t;

long         mstack_init();
void         mstack_release();


mstack_t     mstack_create(int items);
void         mstack_destroy(mstack_t stack);

int          mstack_is_full(mstack_t stack);
int          mstack_is_empty(mstack_t stack);

void         mstack_pop(mstack_t stack);
int          mstack_push(mstack_t stack, const void *data, size_t size);
size_t       mstack_get_top(mstack_t stack, void *data, size_t size);


#ifdef __cplusplus
}
#endif

#endif /* _MSTACK_H_ */

/*
 * File name: m_stack.c
 * Author: Seree Rakwong
 * Date: 16-SEP-2013
 *
 */
#include "m_stack.h"

#define MSTACK_SIGNATURE         0x5354434b


#ifdef __cplusplus
extern "C" {
#endif

typedef struct mstack_s
{
    mlist_t        list;
    unsigned long  items;
    unsigned long  signature;
} mstack_s, *mstack_sp;

/*
 * #################### BOF helper functions ####################
 */
mstack_sp mstack_verify_stack(mstack_t stack);



mstack_sp mstack_verify_stack(mstack_t stack)
{
    mstack_sp pstack = (mstack_sp)stack;
    if (!pstack || pstack->signature != MSTACK_SIGNATURE)
        return 0;

    return pstack;
}

/*
 #################### EOF helper functions ####################
 */
long  mstack_init()
{
    return mlist_init();
}

void  mstack_release()
{
    mlist_release();
}

mstack_t mstack_create(int items)
{
    mstack_sp pstack = (mstack_sp)malloc(sizeof(mstack_s));
    if (!pstack)
        return 0;

    if (items <= 0)
        items = 1024;

    pstack->list = mlist_create();
    pstack->items = items;
    pstack->signature = MSTACK_SIGNATURE;

    return (mstack_t)pstack;
}

void mstack_destroy(mstack_t stack)
{
    mstack_sp pstack = mstack_verify_stack(stack);
    if (!pstack)
        return;

    mlist_destroy(pstack->list);
    free(pstack);
    pstack = 0;
}

int mstack_is_full(mstack_t stack)
{
    mstack_sp pstack = mstack_verify_stack(stack);
    if (!pstack)
        return 1;

    return (pstack->items == mlist_get_count(pstack->list) ? 1 : 0);
}

int mstack_is_empty(mstack_t stack)
{
    mstack_sp pstack = mstack_verify_stack(stack);
    if (!pstack)
        return 1;

    return (0 == mlist_get_count(pstack->list) ? 1 : 0);
}


void mstack_pop(mstack_t stack)
{
    mstack_sp pstack = mstack_verify_stack(stack);
    if (!pstack)
        return;

    if (mstack_is_empty(stack) == 1)
        return;

    mlist_remove_first(pstack->list);
}

int mstack_push(mstack_t stack, const void *data, size_t size)
{
    mstack_sp pstack = mstack_verify_stack(stack);
    if (!pstack)
        return 0;

    if (mstack_is_full(stack) == 1)
        return 0;

    mlist_insert_first(pstack->list, data, size);
    return (mlist_get_count(pstack->list));
}

size_t mstack_get_top(mstack_t stack, void *data, size_t size)
{
    mstack_sp pstack = mstack_verify_stack(stack);
    if (!pstack)
        return 0;

    if (mstack_is_empty(stack) == 1)
        return 0;

    return mlist_get_item(mlist_get_begin(pstack->list), data, size);
}


#ifdef __cplusplus
}
#endif

Simple C to Doublly-Linked List

/*
 * File name: m_list.h
 * Author: Seree Rakwong
 * Date: 13-SEP-2013
 *
 * A list is implemented by the range as [a, b) (including a, but b)
 */

#ifndef _MLIST_H_
#define _MLIST_H_

#include <stdlib.h>
#include <string.h>

#ifdef __cplusplus
extern "C" {
#endif

typedef void* mlist_t;
typedef void* mlist_item_t;


/*
 * create and destroy a list
 */
long       mlist_init();
void       mlist_release();

mlist_t    mlist_create();
void       mlist_destroy(mlist_t list);

unsigned long    mlist_get_count(mlist_t list);
/*
 * manipulate data in the list
 */
mlist_item_t        mlist_insert_first(mlist_t list, const void* data, size_t size);
mlist_item_t        mlist_insert_last(mlist_t list, const void* data, size_t size);
mlist_item_t        mlist_insert_before(mlist_t list, mlist_item_t item_after, const void* data, size_t size);
mlist_item_t        mlist_insert_after(mlist_t list, mlist_item_t item_before, const void* data, size_t size);

/*
 * mlist_remove_*
 *   return:
 *     <0 - errors
 *     =0 - successful
 *     >0 - ok, but the list is not created by meo_create_list() or
 *          the list is null object
 */
int        mlist_remove_at(mlist_t list, mlist_item_t item);
int        mlist_remove_all(mlist_t list);
int        mlist_remove_first(mlist_t list);
int        mlist_remove_last(mlist_t list);

int        meo_set_item(mlist_t list, mlist_item_t item, const void* data, size_t size);
/*
 * traversal
 */
mlist_item_t   mlist_get_begin(mlist_t list);
mlist_item_t   mlist_get_end(mlist_t list);
mlist_item_t   mlist_get_next(mlist_t list, mlist_item_t item);
mlist_item_t   mlist_get_prev(mlist_t list, mlist_item_t item);
size_t         mlist_get_item(mlist_item_t item, void* data, size_t size);    /*deep copy*/
void*          mlist_get_item_at(mlist_item_t item, size_t* size); /*copy pointer*/
void           mlist_set_item_at(mlist_item_t item, void* data, size_t size); /*copy pointer*/
/*
 * int (*pf_enum)(const void*, size_t)
 *   return 0 = continue reading
 *          otherwise break
 */
void           mlist_enumerate_items(mlist_t list, int (*pf_enum)(const void*, size_t));

/*
 * int (*pf_cmp)(const void*, size_t, const void*, size_t)
 *   return 0 = items are equal
 *          otherwise not equal
 */
mlist_item_t   mlist_find_first(mlist_t list, const void* data, size_t size, int (*pf_cmp)(const void*, size_t, const void*, size_t));
mlist_item_t   mlist_find_next(mlist_t list, mlist_item_t next_item, const void* data, size_t size, int (*pf_cmp)(const void*, size_t, const void*, size_t));

#ifdef __cplusplus
}
#endif

#endif /* _MLIST_H_ */


/*
 * File name: m_list.c
 * Author: Seree Rakwong
 * Date: 13-SEP-2013
 */
#include "m_list.h"

#define MLIST_SIGNATURE         0x6c697374
#define MLIST_ITEM_SIGNATURE    0x6c697300
#define MLIST_MAX_ITEMS         0xffffffff

#ifdef __cplusplus
extern "C" {
#endif

/*
 * encapsulate the list and the item list structure
 */
typedef struct mlist_item_s
{
    struct mlist_item_s   *prev;
    struct mlist_item_s   *next;
    void                  *data;
    size_t                 size;
    unsigned long          signature;
    mlist_t                owner;
} mlist_item_s, *mlist_item_sp;

typedef struct mlist_s
{
    struct mlist_item_s   *head;
    struct mlist_item_s   *tail;
    unsigned long          items;
    unsigned long          signature;
} mlist_s, *mlist_sp;

/*
 * #################### BOF helper functions ####################
 */
mlist_sp mlist_verify_list(mlist_t list);
mlist_item_sp mlist_verify_list_item(mlist_t list, mlist_item_t item);
mlist_item_sp mlist_create_list_item(mlist_t list);
void mlist_destroy_list_item(mlist_item_t item);

mlist_sp mlist_verify_list(mlist_t list)
{
    mlist_sp plist = (mlist_sp)list;
    if (!plist || plist->signature != MLIST_SIGNATURE)
        return 0;
    return plist;
}

mlist_item_sp mlist_verify_list_item(mlist_t list, mlist_item_t item)
{
    mlist_sp plist = (mlist_sp)list;
    mlist_item_sp pitem = (mlist_item_sp)item;
    if (!plist || !pitem || pitem->signature != MLIST_ITEM_SIGNATURE || pitem->owner != list)
        return 0;
    return pitem;
}

mlist_item_sp mlist_create_list_item(mlist_t list)
{
    mlist_item_sp pitem = (mlist_item_sp)malloc(sizeof(mlist_item_s));
    if (!pitem)
    {
        return 0;
    }
    pitem->next = 0;
    pitem->prev = 0;
    pitem->data = 0;
    pitem->size = 0;
    pitem->signature = (long)MLIST_ITEM_SIGNATURE;
    pitem->owner = list;
    return pitem;
}

void mlist_destroy_list_item(mlist_item_t item)
{
    mlist_item_sp pitem = (mlist_item_sp)item;
    free(pitem->data);
    free(pitem);
    pitem = 0;
}

/*
#################### EOF helper functions ####################
*/

static mlist_sp g_pNullList = 0;

long
mlist_init()
{
    if (!g_pNullList)
    {
        g_pNullList = (mlist_sp)mlist_create();
        if (!g_pNullList)
            return 0;
    }
    return 1;
}

void
mlist_release()
{
    mlist_destroy(g_pNullList);
    g_pNullList = 0;
}

mlist_t mlist_create()
{
    /*
    * allocate a new memory block
    */
    mlist_sp plist = (mlist_sp)malloc(sizeof(mlist_s));
    if (!plist)
    {
        return 0;
    }
    /*
    * initialize the list
    * at the initialization, its head must be pointed to its tail
    */
    plist->tail = mlist_create_list_item((mlist_t)plist);
    if (!plist->tail)
    {
        mlist_destroy((mlist_t)plist);
        return 0;
    }
    plist->head = plist->tail;
    plist->items = 0;
    plist->signature = MLIST_SIGNATURE;

    return (mlist_t)plist;
}

void mlist_destroy(mlist_t list)
{
    mlist_sp plist = mlist_verify_list(list);
    if (!plist)
        return;
    /*
    * remove all items in the list
    */
    mlist_remove_all(list);
    /*
    * free the memory block
    */
    mlist_destroy_list_item((mlist_item_t)plist->tail);
    free(plist);
    list = 0;
}

unsigned long mlist_get_count(mlist_t list)
{
    mlist_sp plist = mlist_verify_list(list);
    if (!plist)
        return 0;
    return plist->items;
}

int mlist_remove_all(mlist_t list)
{
    mlist_item_sp pitem = 0;
    mlist_item_t item = 0;
    mlist_sp plist = mlist_verify_list(list);
    if (plist == 0)
        return 1;

    item = mlist_get_begin(list);
    while (item != mlist_get_end(list))
    {
        pitem = mlist_verify_list_item(list, item);
        /*
        * read the next item before removing the current item
        */
        item = mlist_get_next(list, item);

        mlist_destroy_list_item((mlist_item_t)pitem);
    }
    /*
    * set the tail and head of the list
    */
    plist->tail->prev = 0;
    plist->head = plist->tail;
    plist->items = 0;

    return 0;
}

int mlist_remove_at(mlist_t list, mlist_item_t item)
{
    mlist_sp plist = mlist_verify_list(list);
    mlist_item_sp pitem = mlist_verify_list_item(list, item);

    /* is item ok to be removed? */
    if (!plist || !pitem)
        return 0;

    /* is it a head item? */
    if (pitem == plist->head)
        return mlist_remove_first(list);

    /* is it a tail item? */
    if (pitem == plist->tail)
        return mlist_remove_last(list);

    /* link them */
    if (pitem->next)
        pitem->next->prev = pitem->prev;
    if (pitem->prev)
        pitem->prev->next = pitem->next;

    /* remove it */
    mlist_destroy_list_item(item);

    if (plist->items > 0)
        plist->items--;

    return 0;
}

int mlist_remove_first(mlist_t list)
{
    mlist_item_sp first = 0;
    mlist_sp plist = mlist_verify_list(list);
    if (!plist)
        return 0;

    first = plist->head;
    if (first == plist->tail)
        /* no more item to remove */
        return 0;

    plist->head = first->next;
    plist->head->prev = 0;
    /* ok, we have already freed */
    mlist_destroy_list_item((mlist_item_t)first);

    if (plist->items > 0)
        plist->items--;

    return 0;
}

int mlist_remove_last(mlist_t list)
{
    mlist_item_sp last = 0;
    mlist_sp plist = mlist_verify_list(list);
    if (!plist)
        return 0;

    last = plist->tail->prev;
    if (!last)
        /* no more item to remove */
        return 0;

    plist->tail->prev = last->prev;
    if (last->prev)
        last->prev->next = plist->tail;

    /* ok, we have already freed */
    mlist_destroy_list_item((mlist_item_t)last);

    if (plist->items > 0)
        plist->items--;

    return 0;
}

int mlist_set_item(mlist_t list, mlist_item_t item, const void* data, size_t size)
{
    mlist_sp plist = mlist_verify_list(list);
    mlist_item_sp pitem = mlist_verify_list_item(list, item);
    void* new_data = malloc(size);

    if (!plist || !pitem || !data || size == 0 || !new_data)
        return 1;

    /* clear old data */
    free(pitem->data);

    /* allocate the new data size */
    pitem->size = size;
    pitem->data = new_data;
    memset(pitem->data, 0, size);
    memcpy(pitem->data, data, size);

    return 0;
}

mlist_item_t mlist_get_begin(mlist_t list)
{
    mlist_sp plist = mlist_verify_list(list);
    if (!plist)
        return 0;

    return (mlist_item_t)plist->head;
}

mlist_item_t mlist_get_end(mlist_t list)
{
    mlist_sp plist = mlist_verify_list(list);
    if (!plist)
        return 0;

    return (mlist_item_t)plist->tail;
}

mlist_item_t mlist_get_next(mlist_t list, mlist_item_t item)
{
    mlist_sp plist = mlist_verify_list(list);
    mlist_item_sp pitem = mlist_verify_list_item(list, item);

    if (!plist || !pitem)
        return 0;

    return (mlist_item_t)pitem->next;
}

mlist_item_t   mlist_get_prev(mlist_t list, mlist_item_t item)
{
    mlist_sp plist = mlist_verify_list(list);
    mlist_item_sp pitem = mlist_verify_list_item(list, item);

    if (!plist || !pitem)
        return 0;

    return (mlist_item_t)pitem->prev;
}
size_t mlist_get_item(mlist_item_t item, void* data, size_t size)
{
    mlist_item_sp pitem = (mlist_item_sp)item;
    if (!item || !data)
        return 0;

    if (size > pitem->size)
        size = pitem->size;

    memset(data, 0, size);
    memcpy(data, pitem->data, size);
    return size;
}

void* mlist_get_item_at(mlist_item_t item, size_t* size) /*copy pointer*/
{
    mlist_item_sp pitem = (mlist_item_sp)item;
    if (!item)
        return 0;

    *size = pitem->size;
    return pitem->data;
}

void mlist_set_item_at(mlist_item_t item, void* data, size_t size) /*copy pointer*/
{
    mlist_item_sp pitem = (mlist_item_sp)item;
    if (!item)
        return;

    pitem->size = size;
    pitem->data = data;
}

mlist_item_t mlist_insert_first(mlist_t list, const void* data, size_t size)
{
    mlist_item_sp pitem = 0;
    mlist_sp plist = mlist_verify_list(list);
    void* new_data = 0;

    if (!plist || !data || size == 0)
        return 0;

    if (plist->items == MLIST_MAX_ITEMS)
    {
        return 0;
    }

    new_data = malloc(size);
    if (!new_data)
    {
        return 0;
    }

    pitem = mlist_create_list_item(list);
    if (!pitem)
    {
        return 0;
    }
    /*
    * copy data now
    */
    pitem->size = size;
    pitem->data = new_data;
    memset(pitem->data, 0, size);
    memcpy(pitem->data, data, size);
    /*
    * link the new item to the list
    */
    pitem->next = plist->head;
    plist->head->prev = pitem;
    plist->head = pitem;

    plist->items++;

    return (mlist_item_t)pitem;
}

mlist_item_t mlist_insert_last(mlist_t list, const void* data, size_t size)
{
    mlist_item_sp pitem = 0;
    mlist_sp plist = mlist_verify_list(list);
    void* new_data = 0;

    if (!plist || !data || size == 0)
        return 0;

    if (plist->items == MLIST_MAX_ITEMS)
    {
        return 0;
    }

    new_data = malloc(size);
    if (!new_data)
    {
        return 0;
    }

    pitem = mlist_create_list_item(list);
    if (!pitem)
    {
        return 0;
    }
    /*
    * copy data now
    */
    pitem->size = size;
    pitem->data = new_data;
    memset(pitem->data, 0, size);
    memcpy(pitem->data, data, size);
    /*
    * link the new item to the list
    */
    pitem->next = plist->tail;
    pitem->prev = plist->tail->prev;
    if (plist->tail->prev && plist->tail->prev->next)
        plist->tail->prev->next = pitem;
    plist->tail->prev = pitem;
    if (plist->head == plist->tail)
        plist->head = pitem;

    plist->items++;

    return (mlist_item_t)pitem;

}


mlist_item_t mlist_insert_before(mlist_t list, mlist_item_t item_after, const void* data, size_t size)
{
    mlist_item_sp pitem = 0;
    mlist_sp plist = mlist_verify_list(list);
    mlist_item_sp pitem_after = mlist_verify_list_item(list, item_after);
    void* new_data = 0;

    if (!pitem_after || pitem_after == plist->head)
    {
        return mlist_insert_first(list, data, size);
    }

    if (!plist || !data || size == 0)
        return 0;

    if (plist->items == MLIST_MAX_ITEMS)
    {
        return 0;
    }

    new_data = malloc(size);
    if (!new_data)
    {
        return 0;
    }

    pitem = mlist_create_list_item(list);
    if (!pitem)
    {
        return 0;
    }
    /*
    * copy data now
    */
    pitem->size = size;
    pitem->data = new_data;
    memset(pitem->data, 0, size);
    memcpy(pitem->data, data, size);
    /*
    * link the new item to the list
    */
    pitem->next = pitem_after;
    pitem->prev = pitem_after->prev;
    if (pitem_after->prev && pitem_after->prev->next)
        pitem_after->prev->next = pitem;
    pitem_after->prev = pitem;

    plist->items++;

    return (mlist_item_t)pitem;
}

mlist_item_t mlist_insert_after(mlist_t list, mlist_item_t item_before, const void* data, size_t size)
{
    mlist_item_sp pitem = 0;
    mlist_sp plist = mlist_verify_list(list);
    mlist_item_sp pitem_before = mlist_verify_list_item(list, item_before);
    void* new_data = 0;

    if (!pitem_before || pitem_before == plist->tail){
        return mlist_insert_last(list, data, size);
    }

    if (!plist || !data || size == 0)
        return 0;

    if (plist->items == MLIST_MAX_ITEMS)
    {
        return 0;
    }

    new_data = malloc(size);
    if (!new_data)
    {
        return 0;
    }

    pitem = mlist_create_list_item(list);
    if (!pitem)
    {
        return 0;
    }
    /*
    * copy data now
    */
    pitem->size = size;
    pitem->data = new_data;
    memset(pitem->data, 0, size);
    memcpy(pitem->data, data, size);

    /*
    * link the new item to the list
    */
    pitem->prev = pitem_before;
    pitem->next = pitem_before->next;
    if (pitem_before->next)
        pitem_before->next->prev = pitem;
    pitem_before->next = pitem;

    plist->items++;

    return (mlist_item_t)pitem;
}

mlist_item_t mlist_find_first(mlist_t list, const void* data, size_t size, int(*pf_cmp)(const void*, size_t, const void*, size_t))
{
    mlist_item_t item = mlist_get_begin(list);
    for (; item != mlist_get_end(list); item = mlist_get_next(list, item))
    {
        mlist_item_sp pitem = (mlist_item_sp)item;
        if (pf_cmp(data, size, pitem->data, pitem->size) == 0)
        {
            return item;
        }
    }
    return 0;
}

mlist_item_t mlist_find_next(mlist_t list, mlist_item_t next_item, const void* data, size_t size, int(*pf_cmp)(const void*, size_t, const void*, size_t))
{
    mlist_item_t item = next_item;
    for (; item != mlist_get_end(list); item = mlist_get_next(list, item))
    {
        mlist_item_sp pitem = (mlist_item_sp)item;
        if (pf_cmp(data, size, pitem->data, pitem->size) == 0)
        {
            return item;
        }
    }
    return 0;
}

void mlist_enumerate_items(mlist_t list, int(*pf_enum)(const void*, size_t))
{
    mlist_item_t item = mlist_get_begin(list);
    for (; item != mlist_get_end(list); item = mlist_get_next(list, item))
    {
        mlist_item_sp pitem = (mlist_item_sp)item;
        if (pf_enum(pitem->data, pitem->size) != 0)
        {
            break;
        }
    }
}

#ifdef __cplusplus
}
#endif

Simple C to create an event (pre/on/post)

#include <stdio.h>
/*
#define STRINGIZE(x)           #x
#define STRINGIZE_VALUE_OF(x)  STRINGIZE(x)
*/

struct _inparm_t;
struct _outparm_t;
typedef struct _inparm_t inparm_t;
typedef struct _outparm_t outparm_t;
typedef long (*fnl_ppapi)(const inparm_t*, outparm_t*);
typedef long (*fnl_api)(const inparm_t*, outparm_t*, fnl_ppapi, fnl_ppapi);

struct abc_parm
{
  long a;
  long b;
  long res;
};

long abc_preadd(const inparm_t* in, outparm_t* out)
{
  long rc = 0;
  if (!in)
  {
    printf("no in param\n");
  }
  if (!out)
  {
    printf("no out param\n");
  }
  return rc;
}

long abc_postadd(const inparm_t* in, outparm_t* out)
{
  long rc = 0;
  struct abc_parm* inp = 0;
  struct abc_parm* outp = 0;
  if (in)
  {
    inp = (struct abc_parm*)in;
  }
  if (out)
  {
    outp = (struct abc_parm*)out;
    if (inp)
    {
      printf("%ld + %ld = %ld\n",
        inp->a, inp->b, outp->res);
    }
  }
  return rc;
}

long abc_add(const inparm_t* in, outparm_t* out, fnl_ppapi pre, fnl_ppapi post)
{
  long rc = 0;
  struct abc_parm* inp = 0;
  struct abc_parm* outp = 0;

  if (pre && (rc = pre(in, out)) != 0)
  {
    return rc;
  }

  /* do something here */
  if (in)
  {
    inp = (struct abc_parm*)in;
  }
  if (out)
  {
    outp = (struct abc_parm*)out;
    if (inp)
    {
      outp->res = (inp->a + inp->b);
    }
  }

  if (post && (rc = post(in, out)) != 0)
  {
    return rc;
  }
  return rc;
}


int main(int argc, char* argv[])
{
  /*printf("version: %s\n", STRINGIZE_VALUE_OF(VERSION));*/
  struct abc_parm parm = { 1, 2, 0 };
  abc_add((const inparm_t*)&parm, (outparm_t*)&parm, abc_preadd, abc_postadd);


  abc_add(0, 0, abc_preadd, abc_postadd);
  return 0;
}

Is a prime number?

  1 #include <stdio.h>
  2 #include <stdlib.h>
  3 #include <string.h>
  4
  5 class prime_t
  6 {
  7 private:
  8   long max_number;
  9   long blocks;
 10   char *a_primes;
 11
 12 public:
 13   prime_t(long max_number = 100);
 14   virtual ~prime_t();
 15
 16   bool is_prime(long number) { return get(number); }
 17
 18 private:
 19   void init();
 20   void release();
 21
 22   void set(long number, bool flag);
 23   bool get(long number);
 24 };
 25
 26 prime_t::prime_t(long max_number)
 27   : max_number(max_number),
 28     a_primes(0),
 29     blocks(1)
 30 {
 31   init();
 32 }
 33 prime_t::~prime_t()
 34 {
 35   release();
 36 }
 37 void prime_t::init()
 38 {
 39   if (max_number <= 1) {
 40     max_number = 100;
 41   }
 42   blocks = (max_number/8) + 1;
 43   a_primes = new char[blocks];
 44   memset(a_primes, 0xff, blocks);
 45
 46   set(0, false); set(1, false);
 47
 48   for (long l=2; l<=max_number; ++l) {
 49     if (!get(l)) continue;
 50     for (long l2=l*2; l2<=max_number; l2+=l) {
 51       set(l2, false);
 52     }
 53   }
 54 }
 55 void prime_t::release()
 56 {
 57   if (a_primes) {
 58     delete[] a_primes;
 59   }
 60   a_primes = 0;
 61 }
 62 void prime_t::set(long number, bool flag)
 63 {
 64   long block = number/8;
 65   int  pos   = number%8;
 66   char mask  = ~(0x01 << pos);
 67   a_primes[block] = (a_primes[block] & mask) | ((0x01 & (char)flag) << pos);
 68 }
 69 bool prime_t::get(long number)
 70 {
 71   long block = number/8;
 72   int  pos   = number%8;
 73   char mask  = (0x01 << pos);
 74   return (a_primes[block] & mask );
 75 }
 76
 77 int main(int argc, char *argv[])
 78 {
 79   long max_number = (argc > 1 ? atol(argv[1]) : 100);
 80   prime_t prime(max_number);
 81
 82   int cnt = 1;
 83   for (long l=0; l<=max_number; ++l) {
 84     if (!prime.is_prime(l)) continue;
 85     printf("%8ld%s", l, (cnt%10 == 0 ? "\n" : ""));
 86     ++cnt;
 87   }
 88   printf("\n");
 45
 46   set(0, false); set(1, false);
 47
 48   for (long l=2; l<=max_number; ++l) {
 49     if (!get(l)) continue;
 50     for (long l2=l*2; l2<=max_number; l2+=l) {
 51       set(l2, false);
 52     }
 53   }
 54 }
 55 void prime_t::release()
 56 {
 57   if (a_primes) {
 58     delete[] a_primes;
 59   }
 60   a_primes = 0;
 61 }
 62 void prime_t::set(long number, bool flag)
 63 {
 64   long block = number/8;
 65   int  pos   = number%8;
 66   char mask  = ~(0x01 << pos);
 67   a_primes[block] = (a_primes[block] & mask) | ((0x01 & (char)flag) << pos);
 68 }
 69 bool prime_t::get(long number)
 70 {
 71   long block = number/8;
 72   int  pos   = number%8;
 73   char mask  = (0x01 << pos);
 74   return (a_primes[block] & mask );
 75 }
 76
 77 int main(int argc, char *argv[])
 78 {
 79   long max_number = (argc > 1 ? atol(argv[1]) : 100);
 80   prime_t prime(max_number);
 81
 82   int cnt = 1;
 83   for (long l=0; l<=max_number; ++l) {
 84     if (!prime.is_prime(l)) continue;
 85     printf("%8ld%s", l, (cnt%10 == 0 ? "\n" : ""));
 86     ++cnt;
 87   }
 88   printf("\n");
 89
 90   return 0;
 91 }
 92