hpdf 2.0.8

data/ext/hpdf_string.c

@@ -0,0 +1,189 @@
+/*
+ * << Haru Free PDF Library 2.0.0 >> -- hpdf_string.h
+ *
+ * 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_objects.h"
+
+static const HPDF_BYTE UNICODE_HEADER[] = {
+    0xFE, 0xFF
+};
+
+
+HPDF_String
+HPDF_String_New  (HPDF_MMgr        mmgr,
+                  const char  *value,
+                  HPDF_Encoder     encoder)
+{
+    HPDF_String obj;
+
+    HPDF_PTRACE((" HPDF_String_New\n"));
+
+    obj = (HPDF_String)HPDF_GetMem (mmgr, sizeof(HPDF_String_Rec));
+    if (obj) {
+        HPDF_MemSet (&obj->header, 0, sizeof(HPDF_Obj_Header));
+        obj->header.obj_class = HPDF_OCLASS_STRING;
+
+        obj->mmgr = mmgr;
+        obj->error = mmgr->error;
+        obj->encoder = encoder;
+        obj->value = NULL;
+        obj->len = 0;
+
+        if (HPDF_String_SetValue (obj, value) != HPDF_OK) {
+            HPDF_FreeMem (obj->mmgr, obj);
+            return NULL;
+        }
+    }
+
+    return obj;
+}
+
+
+HPDF_STATUS
+HPDF_String_SetValue  (HPDF_String      obj,
+                       const char  *value)
+{
+    HPDF_UINT len;
+    HPDF_STATUS ret = HPDF_OK;
+
+    HPDF_PTRACE((" HPDF_String_SetValue\n"));
+
+    if (obj->value) {
+        HPDF_FreeMem (obj->mmgr, obj->value);
+        obj->len = 0;
+    }
+
+    len = HPDF_StrLen(value, HPDF_LIMIT_MAX_STRING_LEN + 1);
+
+    if (len > HPDF_LIMIT_MAX_STRING_LEN)
+        return HPDF_SetError (obj->error, HPDF_STRING_OUT_OF_RANGE, 0);
+
+    obj->value = (char *)HPDF_GetMem (obj->mmgr, len + 1);
+    if (!obj->value)
+        return HPDF_Error_GetCode (obj->error);
+
+    HPDF_StrCpy (obj->value, value, obj->value + len);
+    obj->len = len;
+
+    return ret;
+}
+
+void
+HPDF_String_Free  (HPDF_String  obj)
+{
+    if (!obj)
+        return;
+
+    HPDF_PTRACE((" HPDF_String_Free\n"));
+
+    HPDF_FreeMem (obj->mmgr, obj->value);
+    HPDF_FreeMem (obj->mmgr, obj);
+}
+
+
+HPDF_STATUS
+HPDF_String_Write  (HPDF_String   obj,
+                    HPDF_Stream   stream,
+                    HPDF_Encrypt  e)
+{
+    HPDF_STATUS ret;
+
+    /*
+     *  When encoder is not NULL, text is changed to unicode using encoder,
+     *  and it outputs by HPDF_write_binary method.
+     */
+
+    HPDF_PTRACE((" HPDF_String_Write\n"));
+
+    if (e)
+        HPDF_Encrypt_Reset (e);
+
+    if (obj->encoder == NULL) {
+        if (e) {
+            if ((ret = HPDF_Stream_WriteChar (stream, '<')) != HPDF_OK)
+                return ret;
+
+            if ((ret = HPDF_Stream_WriteBinary (stream, obj->value,
+                    HPDF_StrLen (obj->value, -1), e)) != HPDF_OK)
+                return ret;
+
+            return HPDF_Stream_WriteChar (stream, '>');
+        } else {
+            return HPDF_Stream_WriteEscapeText (stream, obj->value);
+        }
+    } else {
+        HPDF_BYTE* src = obj->value;
+        HPDF_BYTE buf[HPDF_TEXT_DEFAULT_LEN * 2];
+        HPDF_UINT tmp_len = 0;
+        HPDF_BYTE* pbuf = buf;
+        HPDF_INT32 len = obj->len;
+        HPDF_ParseText_Rec  parse_state;
+        HPDF_UINT i;
+
+        if ((ret = HPDF_Stream_WriteChar (stream, '<')) != HPDF_OK)
+           return ret;
+
+        if ((ret = HPDF_Stream_WriteBinary (stream, UNICODE_HEADER, 2, e))
+                        != HPDF_OK)
+            return ret;
+
+        HPDF_Encoder_SetParseText (obj->encoder, &parse_state, src, len);
+
+        for (i = 0; i < len; i++) {
+            HPDF_BYTE b = src[i];
+            HPDF_UNICODE tmp_unicode;
+            HPDF_ByteType btype = HPDF_Encoder_ByteType (obj->encoder,
+                    &parse_state);
+
+            if (tmp_len >= HPDF_TEXT_DEFAULT_LEN - 1) {
+                if ((ret = HPDF_Stream_WriteBinary (stream, buf,
+                            tmp_len * 2, e)) != HPDF_OK)
+                    return ret;
+
+                tmp_len = 0;
+                pbuf = buf;
+            }
+
+            if (btype != HPDF_BYTE_TYPE_TRIAL) {
+                if (btype == HPDF_BYTE_TYPE_LEAD) {
+                    HPDF_BYTE b2 = src[i + 1];
+                    HPDF_UINT16 char_code = (HPDF_UINT) b * 256 + b2;
+
+                    tmp_unicode = HPDF_Encoder_ToUnicode (obj->encoder,
+                                char_code);
+                } else {
+                    tmp_unicode = HPDF_Encoder_ToUnicode (obj->encoder, b);
+                }
+
+                HPDF_UInt16Swap (&tmp_unicode);
+                HPDF_MemCpy (pbuf, (HPDF_BYTE*)&tmp_unicode, 2);
+                pbuf += 2;
+                tmp_len++;
+            }
+        }
+
+        if (tmp_len > 0) {
+            if ((ret = HPDF_Stream_WriteBinary (stream, buf, tmp_len * 2, e))
+                            != HPDF_OK)
+                return ret;
+        }
+
+        if ((ret = HPDF_Stream_WriteChar (stream, '>')) != HPDF_OK)
+            return ret;
+    }
+
+    return HPDF_OK;
+}
+

data/ext/hpdf_utils.c

@@ -0,0 +1,438 @@
+/*
+ * << Haru Free PDF Library 2.0.0 >> -- HPDF_utils.c
+ *
+ * Copyright (c) 1999-2004 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 <stdlib.h>
+#include "hpdf_utils.h"
+#include "hpdf_consts.h"
+
+/*---------------------------------------------------------------------------*/
+
+HPDF_INT
+HPDF_AToI  (const char  *s)
+{
+    HPDF_BOOL flg = HPDF_FALSE;
+    HPDF_INT  v = 0;
+
+    /* increment pointer until the charactor of 's' is not
+     * white-space-charactor.
+     */
+    while (*s) {
+        if (HPDF_IS_WHITE_SPACE(*s))
+            s++;
+        else {
+            if (*s == '-') {
+                flg = HPDF_TRUE;
+                s++;
+            }
+            break;
+        }
+    }
+
+    while (*s >= '0' && *s <= '9') {
+        v *= 10;
+        v += *s - '0';
+        s++;
+    }
+
+    if (flg)
+        v *= -1;
+
+    return v;
+}
+
+
+HPDF_DOUBLE
+HPDF_AToF  (const char  *s)
+{
+    HPDF_BOOL flg = HPDF_FALSE;
+    HPDF_INT i = 0;
+    HPDF_DOUBLE v;
+    HPDF_INT tmp = 1;
+
+    /* increment pointer until the charactor of 's' is not
+     * white-space-charactor.
+     */
+    while (*s) {
+        if (HPDF_IS_WHITE_SPACE(*s))
+            s++;
+        else {
+            if (*s == '-') {
+                flg = HPDF_TRUE;
+                s++;
+            }
+            break;
+        }
+    }
+
+    while (*s >= '0' && *s <= '9') {
+        if (i > 3276)
+            break;
+
+        i *= 10;
+        i += *s - '0';
+        s++;
+    }
+
+    if (*s == '.') {
+        s++;
+        while (*s >= '0' && *s <= '9') {
+            if (i > 214748364)
+                break;
+
+            i *= 10;
+            i += *s - '0';
+            s++;
+            tmp *= 10;
+        }
+    }
+
+    v = (HPDF_DOUBLE)i / tmp;
+
+    if (flg)
+        v *= -1;
+
+    return v;
+}
+
+
+char*
+HPDF_IToA  (char        *s,
+            HPDF_INT32   val,
+            char        *eptr)
+{
+    char* t;
+    char buf[HPDF_INT_LEN + 1];
+
+    if (val < 0) {
+        if (val < HPDF_LIMIT_MIN_INT)
+            val = HPDF_LIMIT_MIN_INT;
+        *s++ = '-';
+        val = -val;
+    } else if (val > HPDF_LIMIT_MAX_INT) {
+        val = HPDF_LIMIT_MAX_INT;
+    } else if (val == 0) {
+        *s++ = '0';
+    }
+
+    t = buf + HPDF_INT_LEN;
+    *t-- = 0;
+
+    while (val > 0) {
+        *t = (char)(val % 10) + '0';
+        val /= 10;
+        t--;
+    }
+
+    t++;
+    while (s < eptr && *t != 0)
+      *s++ = *t++;
+    *s = 0;
+
+    return s;
+}
+
+
+char*
+HPDF_IToA2  (char         *s,
+             HPDF_UINT32   val,
+             HPDF_UINT     len)
+{
+    char* t;
+    char* u;
+
+    if (val > HPDF_LIMIT_MAX_INT)
+        val = HPDF_LIMIT_MAX_INT;
+
+    u = s + len - 1;
+    *u = 0;
+    t = u - 1;
+    while (val > 0 && t >= s) {
+        *t = (char)(val % 10) + '0';
+        val /= 10;
+        t--;
+    }
+
+    while (s <= t)
+        *t-- = '0';
+
+    return s + len - 1;
+}
+
+
+char*
+HPDF_FToA  (char       *s,
+            HPDF_REAL   val,
+            char       *eptr)
+{
+    HPDF_INT32 int_val;
+    HPDF_INT32 fpart_val;
+    char buf[HPDF_REAL_LEN + 1];
+    char* sptr = s;
+    char* t;
+    HPDF_UINT32 i;
+
+    if (val > HPDF_LIMIT_MAX_REAL)
+        val = HPDF_LIMIT_MAX_REAL;
+    else
+    if (val < HPDF_LIMIT_MIN_REAL)
+        val = HPDF_LIMIT_MIN_REAL;
+
+    t = buf + HPDF_REAL_LEN;
+    *t-- = 0;
+
+    if (val < 0) {
+        *s++ = '-';
+        val = -val;
+    }
+
+    /* separate an integer part and a decimal part. */
+    int_val = (HPDF_INT32)(val + 0.000005);
+    fpart_val = (HPDF_INT32)((HPDF_REAL)(val - int_val + 0.000005) * 100000);
+
+    /* process decimal part */
+    for (i = 0; i < 5; i++) {
+        *t = (char)(fpart_val % 10) + '0';
+        fpart_val /= 10;
+        t--;
+    }
+
+    /* process integer part */
+    *t-- = '.';
+    *t = '0';
+    if (int_val == 0)
+        t--;
+
+    while (int_val > 0) {
+        *t = (char)(int_val % 10) + '0';
+        int_val /= 10;
+        t--;
+    }
+
+    t++;
+    while (s <= eptr && *t != 0)
+        *s++ = *t++;
+    s--;
+
+    /* delete an excessive decimal portion. */
+    while (s > sptr) {
+        if (*s == '0')
+            *s = 0;
+        else {
+            if (*s == '.')
+                *s = 0;
+            break;
+        }
+        s--;
+    }
+
+    return (*s == 0) ? s : ++s;
+}
+
+
+HPDF_BYTE*
+HPDF_MemCpy  (HPDF_BYTE*         out,
+              const HPDF_BYTE   *in,
+              HPDF_UINT          n)
+{
+    while (n > 0) {
+        *out++ = *in++;
+        n--;
+    }
+
+    return out;
+}
+
+
+HPDF_BYTE*
+HPDF_StrCpy  (char          *out,
+              const char    *in,
+              char          *eptr)
+{
+    if (in != NULL) {
+        while (eptr > out && *in != 0)
+            *out++ = *in++;
+    }
+
+    *out = 0;
+
+    return out;
+}
+
+
+HPDF_INT
+HPDF_MemCmp  (const HPDF_BYTE   *s1,
+              const HPDF_BYTE   *s2,
+              HPDF_UINT          n)
+{
+    if (n == 0)
+        return 0;
+
+    while (*s1 == *s2) {
+        n--;
+        if (n == 0)
+            return 0;
+        s1++;
+        s2++;
+    }
+
+    return *s1 - *s2;
+}
+
+
+HPDF_INT
+HPDF_StrCmp  (const char   *s1,
+              const char   *s2)
+{
+    if (!s1 || !s2) {
+        if (!s1 && s2)
+            return -1;
+        else
+            return 1;
+    }
+
+    while (*s1 == *s2) {
+        s1++;
+        s2++;
+        if (*s1 == 0 || *s2 == 0)
+            break;
+    }
+
+    return (HPDF_BYTE)*s1 - (HPDF_BYTE)*s2;
+}
+
+
+void*
+HPDF_MemSet  (void        *s,
+              HPDF_BYTE    c,
+              HPDF_UINT    n)
+{
+    HPDF_BYTE* b = (HPDF_BYTE*)s;
+
+    while (n > 0) {
+        *b = c;
+        b++;
+        n--;
+    }
+
+    return b;
+}
+
+
+HPDF_UINT
+HPDF_StrLen  (const char   *s,
+              HPDF_INT      maxlen)
+{
+    HPDF_INT len = 0;
+
+    if (!s)
+        return 0;
+
+    while (*s != 0 && (maxlen < 0 || len < maxlen)) {
+        s++;
+        len++;
+    }
+
+    return (HPDF_UINT)len;
+}
+
+
+const char*
+HPDF_StrStr  (const char   *s1,
+              const char   *s2,
+              HPDF_UINT     maxlen)
+{
+    HPDF_UINT len = HPDF_StrLen (s2, -1);
+
+    if (!s1)
+        return NULL;
+
+    if (len == 0)
+        return s1;
+
+    if (maxlen == 0)
+        maxlen = HPDF_StrLen (s1, -1);
+
+    if (maxlen < len)
+        return NULL;
+
+    maxlen -= len;
+    maxlen++;
+
+    while (maxlen > 0) {
+        if (HPDF_MemCmp (s1, s2, len) == 0)
+            return s1;
+
+        s1++;
+        maxlen--;
+    }
+
+    return NULL;
+}
+
+
+HPDF_Box
+HPDF_ToBox  (HPDF_INT16   left,
+             HPDF_INT16   bottom,
+             HPDF_INT16   right,
+             HPDF_INT16   top)
+{
+    HPDF_Box box;
+
+    box.left = left;
+    box.bottom = bottom;
+    box.right = right;
+    box.top = top;
+
+    return box;
+}
+
+
+HPDF_Point
+HPDF_ToPoint  (HPDF_INT16   x,
+               HPDF_INT16   y)
+{
+    HPDF_Point point;
+
+    point.x = x;
+    point.y = y;
+
+    return point;
+}
+
+HPDF_Rect
+HPDF_ToRect  (HPDF_REAL   left,
+              HPDF_REAL   bottom,
+              HPDF_REAL   right,
+              HPDF_REAL   top)
+{
+    HPDF_Rect rect;
+
+    rect.left = left;
+    rect.bottom = bottom;
+    rect.right = right;
+    rect.top = top;
+
+    return rect;
+}
+
+
+void
+HPDF_UInt16Swap  (HPDF_UINT16  *value)
+{
+    HPDF_BYTE u[2];
+
+    HPDF_MemCpy (u, (HPDF_BYTE*)value, 2);
+    *value = (HPDF_UINT16)((HPDF_UINT16)u[0] << 8 | (HPDF_UINT16)u[1]);
+}
+