hpdf 2.0.8

data/ext/hpdf_list.c

@@ -0,0 +1,333 @@
+/*
+ * << Haru Free PDF Library 2.0.0 >> -- hpdf_list.c
+ *
+ * Copyright (c) 1999-2006 Takeshi Kanno <takeshi_kanno@est.hi-ho.ne.jp>
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.
+ * It is provided "as is" without express or implied warranty.
+ *
+ */
+
+#include "hpdf_conf.h"
+#include "hpdf_utils.h"
+#include "hpdf_consts.h"
+#include "hpdf_list.h"
+
+static HPDF_STATUS
+Resize  (HPDF_List  list,
+         HPDF_UINT  count);
+
+
+/*
+ *  HPDF_List_new
+ *
+ *  mmgr :  handle to a HPDF_MMgr object.
+ *  items_per_block :  number of increases of pointers.
+ *
+ *  return:  If HPDF_List_New success, it returns a handle to new HPDF_List
+ *           object, otherwise it returns NULL.
+ *
+ */
+
+HPDF_List
+HPDF_List_New  (HPDF_MMgr  mmgr,
+                HPDF_UINT  items_per_block)
+{
+    HPDF_List list;
+
+    HPDF_PTRACE((" HPDF_List_New\n"));
+
+    if (mmgr == NULL)
+        return NULL;
+
+    list = (HPDF_List)HPDF_GetMem (mmgr, sizeof(HPDF_List_Rec));
+    if (list) {
+        list->mmgr = mmgr;
+        list->error = mmgr->error;
+        list->block_siz = 0;
+        list->items_per_block =
+            (items_per_block <= 0 ? HPDF_DEF_ITEMS_PER_BLOCK : items_per_block);
+        list->count = 0;
+        list->obj = NULL;
+    }
+
+    return list;
+}
+
+/*
+ *  HPDF_List_add
+ *
+ *  list :  Pointer to a HPDF_List object.
+ *  item :  Pointer to a object to be added.
+ *
+ *  return:  If HPDF_List_Add success, it returns HPDF_OK.
+ *           HPDF_FAILD_TO_ALLOC_MEM is returned when the expansion of the
+ *           object list is failed.
+ *
+ */
+
+HPDF_STATUS
+HPDF_List_Add  (HPDF_List  list,
+                void       *item)
+{
+    HPDF_PTRACE((" HPDF_List_Add\n"));
+
+    if (list->count >= list->block_siz) {
+        HPDF_STATUS ret = Resize (list,
+                list->block_siz + list->items_per_block);
+
+        if (ret != HPDF_OK) {
+            return ret;
+        }
+    }
+
+    list->obj[list->count++] = item;
+    return HPDF_OK;
+}
+
+
+/*
+ *  HPDF_List_Insert
+ *
+ *  list   :  Pointer to a HPDF_List object.
+ *  target :  Pointer to the target object.
+ *  item   :  Pointer to a object to be inserted.
+ *
+ *  insert the item before the target.
+ *
+ *  return:  If HPDF_List_Add success, it returns HPDF_OK.
+ *           HPDF_FAILD_TO_ALLOC_MEM is returned when the expansion of the
+ *           object list is failed.
+ *           HPDF_ITEM_NOT_FOUND is returned where the target object is not
+ *           found.
+ *
+ */
+
+HPDF_STATUS
+HPDF_List_Insert  (HPDF_List  list,
+                   void       *target,
+                   void       *item)
+{
+    HPDF_INT target_idx = HPDF_List_Find (list, target);
+    void      *last_item = list->obj[list->count - 1];
+    HPDF_INT i;
+
+    HPDF_PTRACE((" HPDF_List_Insert\n"));
+
+    if (target_idx < 0)
+        return HPDF_ITEM_NOT_FOUND;
+
+    /* move the item of the list to behind one by one. */
+    for (i = list->count - 2; i >= target_idx; i--)
+        list->obj[i + 1] = list->obj[i];
+
+    list->obj[target_idx] = item;
+
+    return HPDF_List_Add (list, last_item);
+}
+
+/*
+ *  HPDF_List_Remove
+ *
+ *  Remove the object specified by item parameter from the list object. The
+ *  memory area that the object uses is not released.
+ *
+ *  list :  Pointer to a HPDF_List object.
+ *  item :  Pointer to a object to be remove.
+ *
+ *  return:  If HPDF_List_Remove success, it returns HPDF_OK.
+ *           HPDF_ITEM_NOT_FOUND is returned when the object specified by item
+ *           parameter is not found.
+ *
+ */
+
+HPDF_STATUS
+HPDF_List_Remove  (HPDF_List  list,
+                   void       *item)
+{
+    HPDF_UINT i;
+    void **obj = list->obj;
+
+    HPDF_PTRACE((" HPDF_List_Remove\n"));
+
+    for (i = 0; i < list->count; i++) {
+        if (*obj == item) {
+            HPDF_List_RemoveByIndex(list, i);
+            return HPDF_OK;
+        } else
+            obj++;
+    }
+
+    return HPDF_ITEM_NOT_FOUND;
+}
+
+/*
+ *  HPDF_List_RemoveByIndex
+ *
+ *  Remove the object by index number.
+ *
+ *  list :  Pointer to a HPDF_List object.
+ *  index :  Index of a object to be remove.
+ *
+ *  return:  If HPDF_List_RemoveByIndex success, it returns HPDF_OK.
+ *           HPDF_ITEM_NOT_FOUND is returned when the value which is specified
+ *           by index parameter is invalid.
+ *
+ */
+
+void*
+HPDF_List_RemoveByIndex  (HPDF_List  list,
+                          HPDF_UINT  index)
+{
+    void *tmp;
+
+    HPDF_PTRACE((" HPDF_List_RemoveByIndex\n"));
+
+    if (list->count <= index)
+        return NULL;
+
+    tmp = list->obj[index];
+
+    while (index < list->count - 1) {
+        list->obj[index] = list->obj[index + 1];
+        index++;
+    }
+
+    list->count--;
+
+    return tmp;
+}
+
+/*
+ *  HPDF_List_ItemAt
+ *
+ *  list :  Pointer to a HPDF_List object.
+ *  index :  Index of a object.
+ *
+ *  return:  If HPDF_List_at success, it returns a pointer to the object.
+ *           otherwise it returns NULL.
+ *
+ */
+
+void*
+HPDF_List_ItemAt  (HPDF_List  list,
+                   HPDF_UINT  index)
+{
+    HPDF_PTRACE((" HPDF_List_ItemAt\n"));
+
+    return (list->count <= index) ? NULL : list->obj[index];
+}
+
+/*
+ *  HPDF_List_free
+ *
+ *  list :  Pointer to a HPDF_List object.
+ *
+ */
+
+void
+HPDF_List_Free  (HPDF_List  list)
+{
+    HPDF_PTRACE((" HPDF_List_Free\n"));
+
+    if (!list)
+        return ;
+
+    HPDF_List_Clear (list);
+    HPDF_FreeMem (list->mmgr, list);
+}
+
+/*
+ *  HPDF_List_Clear
+ *
+ *  list :  Pointer to a HPDF_List object.
+ *
+ */
+
+void
+HPDF_List_Clear  (HPDF_List  list)
+{
+    HPDF_PTRACE((" HPDF_List_Clear\n"));
+
+    if (list->obj)
+        HPDF_FreeMem (list->mmgr, list->obj);
+
+    list->block_siz = 0;
+    list->count = 0;
+    list->obj = NULL;
+}
+
+/*
+ *  Resize
+ *
+ *  list :  Pointer to a HPDF_List object.
+ *  count : The size of array of pointers.
+ *
+ *  return:  If Resize success, it returns HPDF_OK.
+ *           otherwise it returns error-code which is set by HPDF_MMgr object.
+ *
+ */
+
+HPDF_STATUS
+Resize  (HPDF_List   list,
+         HPDF_UINT   count)
+{
+    void **new_obj;
+
+    HPDF_PTRACE((" HPDF_List_Resize\n"));
+
+    if (list->count >= count) {
+        if (list->count == count)
+            return HPDF_OK;
+        else
+            return HPDF_INVALID_PARAMETER;
+    }
+
+    new_obj = (void **)HPDF_GetMem (list->mmgr, count * sizeof(void *));
+
+    if (!new_obj)
+        return HPDF_Error_GetCode (list->error);
+
+    if (list->obj)
+        HPDF_MemCpy ((HPDF_BYTE *)new_obj, (HPDF_BYTE *)list->obj,
+                list->block_siz * sizeof(void *));
+
+    list->block_siz = count;
+    if (list->obj)
+        HPDF_FreeMem (list->mmgr, list->obj);
+    list->obj = new_obj;
+
+    return HPDF_OK;
+}
+
+/*
+ *  HPDF_List_Find
+ *
+ *  list :  Pointer to a HPDF_List object.
+ *  count : the size of array of pointers.
+ *
+ *  return:  If HPDF_List_Find success, it returns index of the object.
+ *           otherwise it returns negative value.
+ *
+ */
+
+HPDF_INT32
+HPDF_List_Find  (HPDF_List  list,
+                 void       *item)
+{
+    HPDF_UINT i;
+
+    HPDF_PTRACE((" HPDF_List_Find\n"));
+
+    for (i = 0; i < list->count; i++) {
+        if (list->obj[i] == item)
+            return i;
+    }
+
+    return -1;
+}
+

data/ext/hpdf_mmgr.c

@@ -0,0 +1,243 @@
+/*
+ * << Haru Free PDF Library 2.0.0 >> -- hpdf_mmgr.c
+ *
+ * Copyright (c) 1999-2006 Takeshi Kanno <takeshi_kanno@est.hi-ho.ne.jp>
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.
+ * It is provided "as is" without express or implied warranty.
+ *
+ */
+
+#include "hpdf_conf.h"
+#include "hpdf_consts.h"
+#include "hpdf_mmgr.h"
+#include "hpdf_utils.h"
+
+#ifndef HPDF_STDCALL
+#ifdef HPDF_DLL_MAKE
+#define HPDF_STDCALL __stdcall
+#else
+#ifdef HPDF_DLL
+#define HPDF_STDCALL __stdcall
+#else
+#define HPDF_STDCALL
+#endif
+#endif
+#endif
+
+static void * HPDF_STDCALL
+InternalGetMem  (HPDF_UINT  size);
+
+static void HPDF_STDCALL
+InternalFreeMem  (void*  aptr);
+
+
+HPDF_MMgr
+HPDF_MMgr_New  (HPDF_Error       error,
+                HPDF_UINT        buf_size,
+                HPDF_Alloc_Func  alloc_fn,
+                HPDF_Free_Func   free_fn)
+{
+    HPDF_MMgr mmgr;
+
+    HPDF_PTRACE((" HPDF_MMgr_New\n"));
+
+    if (alloc_fn)
+        mmgr = (HPDF_MMgr)alloc_fn (sizeof(HPDF_MMgr_Rec));
+    else
+        mmgr = (HPDF_MMgr)InternalGetMem (sizeof(HPDF_MMgr_Rec));
+
+    HPDF_PTRACE(("+%p mmgr-new\n", mmgr));
+
+    if (mmgr != NULL) {
+        /* initialize mmgr object */
+        mmgr->error = error;
+
+
+#ifdef HPDF_MEM_DEBUG
+        mmgr->alloc_cnt = 0;
+        mmgr->free_cnt = 0;
+#endif
+        /*
+         *  if alloc_fn and free_fn are specified, these function is
+         *  used. if not, default function (maybe these will be "malloc" and
+         *  "free") is used.
+         */
+        if (alloc_fn && free_fn) {
+            mmgr->alloc_fn = alloc_fn;
+            mmgr->free_fn = free_fn;
+        } else {
+            mmgr->alloc_fn = InternalGetMem;
+            mmgr->free_fn = InternalFreeMem;
+        }
+
+        /*
+         *  if buf_size parameter is specified, this object is configured
+         *  to be using memory-pool.
+         *
+         */
+        if (!buf_size)
+            mmgr->mpool = NULL;
+        else {
+            HPDF_MPool_Node node;
+
+            node = (HPDF_MPool_Node)mmgr->alloc_fn (sizeof(HPDF_MPool_Node_Rec) +
+                    buf_size);
+
+            HPDF_PTRACE(("+%p mmgr-node-new\n", node));
+
+            if (node == NULL) {
+                HPDF_SetError (error, HPDF_FAILD_TO_ALLOC_MEM, HPDF_NOERROR);
+
+                mmgr->free_fn(mmgr);
+                mmgr = NULL;
+            } else {
+                mmgr->mpool = node;
+                node->buf = (HPDF_BYTE *)node + sizeof(HPDF_MPool_Node_Rec);
+                node->size = buf_size;
+                node->used_size = 0;
+                node->next_node = NULL;
+            }
+
+#ifdef HPDF_MEM_DEBUG
+            mmgr->alloc_cnt += 1;
+#endif
+        }
+
+        mmgr->buf_size = buf_size;
+    } else
+        HPDF_SetError(error, HPDF_FAILD_TO_ALLOC_MEM, HPDF_NOERROR);
+
+    return mmgr;
+}
+
+void
+HPDF_MMgr_Free  (HPDF_MMgr  mmgr)
+{
+    HPDF_MPool_Node node;
+
+    HPDF_PTRACE((" HPDF_MMgr_Free\n"));
+
+    if (mmgr == NULL)
+        return;
+
+    node = mmgr->mpool;
+
+    /* delete all nodes recursively */
+    while (node != NULL) {
+        HPDF_MPool_Node tmp = node;
+        node = tmp->next_node;
+
+        HPDF_PTRACE(("-%p mmgr-node-free\n", tmp));
+        mmgr->free_fn (tmp);
+
+#ifdef HPDF_MEM_DEBUG
+        mmgr->free_cnt++;
+#endif
+
+    }
+
+#ifdef HPDF_MEM_DEBUG
+    HPDF_PRINTF ("# HPDF_MMgr alloc-cnt=%u, free-cnt=%u\n",
+            mmgr->alloc_cnt, mmgr->free_cnt);
+
+    if (mmgr->alloc_cnt != mmgr->free_cnt)
+        HPDF_PRINTF ("# ERROR #\n");
+#endif
+
+    HPDF_PTRACE(("-%p mmgr-free\n", mmgr));
+    mmgr->free_fn (mmgr);
+}
+
+void*
+HPDF_GetMem  (HPDF_MMgr  mmgr,
+              HPDF_UINT  size)
+{
+    void * ptr;
+
+    if (mmgr->mpool) {
+        HPDF_MPool_Node node = mmgr->mpool;
+
+#ifdef HPDF_ALINMENT_SIZ
+        size = (size + (HPDF_ALINMENT_SIZ - 1)) / HPDF_ALINMENT_SIZ;
+        size *= HPDF_ALINMENT_SIZ;
+#endif
+
+        if (node->size - node->used_size >= size) {
+            ptr = (HPDF_BYTE*)node->buf + node->used_size;
+            node->used_size += size;
+            return ptr;
+        } else {
+            HPDF_UINT tmp_buf_siz = (mmgr->buf_size < size) ?  size :
+                mmgr->buf_size;
+
+            node = (HPDF_MPool_Node)mmgr->alloc_fn (sizeof(HPDF_MPool_Node_Rec)
+                    + tmp_buf_siz);
+            HPDF_PTRACE(("+%p mmgr-new-node\n", node));
+
+            if (!node) {
+                HPDF_SetError (mmgr->error, HPDF_FAILD_TO_ALLOC_MEM,
+                        HPDF_NOERROR);
+                return NULL;
+            }
+
+            node->size = tmp_buf_siz;
+        }
+
+        node->next_node = mmgr->mpool;
+        mmgr->mpool = node;
+        node->used_size = size;
+        node->buf = (HPDF_BYTE*)node + sizeof(HPDF_MPool_Node_Rec);
+        ptr = node->buf;
+    } else {
+        ptr = mmgr->alloc_fn (size);
+        HPDF_PTRACE(("+%p mmgr-alloc_fn size=%u\n", ptr, size));
+
+        if (ptr == NULL)
+            HPDF_SetError (mmgr->error, HPDF_FAILD_TO_ALLOC_MEM, HPDF_NOERROR);
+    }
+
+#ifdef HPDF_MEM_DEBUG
+    if (ptr)
+        mmgr->alloc_cnt++;
+#endif
+
+    return ptr;
+}
+
+void
+HPDF_FreeMem  (HPDF_MMgr  mmgr,
+               void       *aptr)
+{
+    if (!aptr)
+        return;
+
+    if (!mmgr->mpool) {
+        HPDF_PTRACE(("-%p mmgr-free-mem\n", aptr));
+        mmgr->free_fn(aptr);
+
+#ifdef HPDF_MEM_DEBUG
+        mmgr->free_cnt++;
+#endif
+    }
+
+    return;
+}
+
+static void * HPDF_STDCALL
+InternalGetMem  (HPDF_UINT  size)
+{
+    return HPDF_MALLOC (size);
+}
+
+static void HPDF_STDCALL
+InternalFreeMem  (void*  aptr)
+{
+    HPDF_FREE (aptr);
+}
+
+