ruby-staci 2.2.9

data/ext/oci8/oranumber_util.c

@@ -0,0 +1,352 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+#include <stdio.h>
+#include <string.h>
+#include "oranumber_util.h"
+
+int oranumber_to_str(const ACINumber *on, char *buf, int buflen)
+{
+    signed char exponent;
+    signed char mantissa[21]; /* terminated by a negative number */
+    int datalen = on->ACINumberPart[0];
+    int len = 0;
+    int idx;
+    int n;
+#define PUTC(chr) do { \
+    if (len < buflen) { \
+        buf[len++] = (chr); \
+    } else { \
+        return ORANUMBER_TOO_SHORT_BUFFER; \
+    } \
+} while(0)
+#define PUTEND() do { \
+    if (len < buflen) { \
+        buf[len] = '\0'; \
+    } else { \
+        return ORANUMBER_TOO_SHORT_BUFFER; \
+    } \
+} while(0)
+
+    if (datalen == 0) {
+        /* too short */
+        return -1;
+    }
+    if (datalen == 1) {
+        if (on->ACINumberPart[1] == 0x80) {
+            /* zero */
+            PUTC('0');
+            PUTEND();
+            return 1;
+        }
+        if (on->ACINumberPart[1] == 0) {
+            /* negative infinity */
+            PUTC('-');
+            PUTC('~');
+            PUTEND();
+            return 2;
+        }
+        /* unexpected format */
+        return -1;
+    }
+    if (datalen == 2) {
+        if (on->ACINumberPart[1] == 255 && on->ACINumberPart[2] == 101) {
+            /* positive infinity */
+            PUTC('~');
+            PUTEND();
+            return 1;
+        }
+    }
+    if (datalen > 21) {
+        /* too long */
+        return -1;
+    }
+    /* normalize exponent and mantissa */
+    if (on->ACINumberPart[1] >= 128) {
+        /* positive number */
+        exponent = on->ACINumberPart[1] - 193;
+        for (idx = 0; idx < on->ACINumberPart[0] - 1; idx++) {
+            mantissa[idx] = on->ACINumberPart[idx + 2] - 1;
+        }
+        mantissa[idx] = -1;
+    } else {
+        /* negative number */
+        exponent = 62 - on->ACINumberPart[1];
+        for (idx = 0; idx < on->ACINumberPart[0] - 1; idx++) {
+            mantissa[idx] = 101 - on->ACINumberPart[idx + 2];
+        }
+        mantissa[idx] = -1;
+        PUTC('-');
+    }
+    /* convert exponent and mantissa to human readable number */
+    idx = 0;
+    if (exponent-- >= 0) {
+        /* integer part */
+        n = mantissa[idx++];
+        if (n / 10 != 0) {
+            PUTC(n / 10 + '0');
+        }
+        PUTC(n % 10 + '0');
+        while (exponent-- >= 0) {
+            n = mantissa[idx++];
+            if (n < 0) {
+                do {
+                    PUTC('0');
+                    PUTC('0');
+                } while (exponent-- >= 0);
+                PUTEND();
+                return len;
+            }
+            PUTC(n / 10 + '0');
+            PUTC(n % 10 + '0');
+        }
+        if (mantissa[idx] < 0) {
+            PUTEND();
+            return len;
+        }
+    } else {
+        PUTC('0');
+    }
+    PUTC('.');
+    /* fractional number part */
+    while (++exponent < -1) {
+        PUTC('0');
+        PUTC('0');
+    }
+    while ((n = mantissa[idx++]) >= 0) {
+        PUTC(n / 10 + '0');
+        PUTC(n % 10 + '0');
+    }
+    if (buf[len - 1] == '0') {
+        len--;
+    }
+    PUTEND();
+    return len;
+}
+
+int oranumber_from_str(ACINumber *on, const char *buf, int buflen)
+{
+    const char *end;
+    int is_positive = 1;
+    char mantissa[41];
+    int dec_point;
+    long exponent = 0;
+    int idx = 0;
+    int i;
+
+    if (buflen < 0) {
+        end = buf + strlen(buf);
+    } else {
+        end = buf + buflen;
+    }
+
+    /* skip leading spaces */
+    while (buf < end && *buf == ' ') {
+        buf++;
+    }
+    if (buf == end) {
+        return ORANUMBER_INVALID_NUMBER;
+    }
+    /* read a sign mark */
+    if (*buf == '+') {
+        buf++;
+    } else if (*buf == '-') {
+        buf++;
+        is_positive = 0;
+    }
+    if (*buf == '~') {
+        buf ++;
+        /* skip trailing spaces */
+        while (buf < end && *buf == ' ') {
+            buf++;
+        }
+        if (buf != end) {
+            return ORANUMBER_INVALID_NUMBER;
+        }
+        if (is_positive) {
+            /* positive infinity */
+            on->ACINumberPart[0] = 2;
+            on->ACINumberPart[1] = 255;
+            on->ACINumberPart[2] = 101;
+        } else {
+            /* negative infinity */
+            on->ACINumberPart[0] = 1;
+            on->ACINumberPart[1] = 0;
+        }
+        return ORANUMBER_SUCCESS;
+    }
+
+    /* next should be number or a dot */
+    if ((*buf < '0' || '9' < *buf) && *buf != '.') {
+        return ORANUMBER_INVALID_NUMBER;
+    }
+    /* skip leading zeros */
+    while (buf < end) {
+        if (*buf == '0') {
+            buf++;
+        } else {
+            break;
+        }
+    }
+    /* read integer part */
+    while (buf < end) {
+        if ('0' <= *buf && *buf <= '9') {
+            if (idx < 41) {
+                mantissa[idx] = *buf - '0';
+            }
+            idx++;
+        } else if (*buf == '.' || *buf == 'E' || *buf == 'e' || *buf == ' ') {
+            break;
+        } else {
+            return ORANUMBER_INVALID_NUMBER;
+        }
+        buf++;
+    }
+    dec_point = idx;
+    /* read fractional part */
+    if (buf < end && *buf == '.') {
+        buf++;
+        if (idx == 0) {
+            /* skip leading zeros */
+            while (buf < end) {
+                if (*buf == '0') {
+                    dec_point--;
+                    buf++;
+                } else {
+                    break;
+                }
+            }
+        }
+        while (buf < end) {
+            if ('0' <= *buf && *buf <= '9') {
+                if (idx < 41) {
+                    mantissa[idx++] = *buf - '0';
+                }
+            } else if (*buf == 'E' || *buf == 'e' || *buf == ' ') {
+                break;
+            } else {
+                return ORANUMBER_INVALID_NUMBER;
+            }
+            buf++;
+        }
+    }
+    /* read exponent part */
+    if (buf < end && (*buf == 'E' || *buf == 'e')) {
+        int negate = 0;
+        buf++;
+        if (buf < end) {
+            if (*buf == '+') {
+                buf++;
+            } else if (*buf == '-') {
+                buf++;
+                negate = 1;
+            }
+        }
+        while (buf < end) {
+            if ('0' <= *buf && *buf <= '9') {
+                exponent *= 10;
+                exponent += *buf - '0';
+            } else if (*buf == ' ') {
+                break;
+            } else {
+                return ORANUMBER_INVALID_NUMBER;
+            }
+            buf++;
+        }
+        if (negate) {
+            exponent = -exponent;
+        }
+    }
+    /* skip trailing spaces */
+    while (buf < end && *buf == ' ') {
+        buf++;
+    }
+    /* final format check */
+    if (buf != end) {
+        return ORANUMBER_INVALID_NUMBER;
+    }
+    /* determine exponent */
+    exponent += dec_point - 1;
+    if (exponent % 2 == 0) {
+        memmove(mantissa + 1, mantissa, 40);
+        mantissa[0] = 0;
+        idx++;
+    }
+    /* round if needed */
+    if (idx > 40) {
+        idx = 40;
+        if (mantissa[40] >= 5) {
+            /* round up */
+            for (i = 39; i >= 0; i--) {
+                mantissa[i]++;
+                if (mantissa[i] == 10) {
+                    mantissa[i] = 0;
+                } else {
+                    break;
+                }
+            }
+            if (i == -1) {
+                /* all figures are rounded up. */
+                mantissa[0] = 0;
+                mantissa[1] = 1;
+                idx = 2;
+                exponent++;
+            }
+        }
+    }
+    /* shrink mantissa scale */
+    while (idx > 0 && mantissa[idx - 1] == 0) {
+        idx--;
+    }
+    /* check zero or underflow */
+    if (idx == 0 || exponent < -130) {
+        on->ACINumberPart[0] = 1;
+        on->ACINumberPart[1] = 0x80;
+        return ORANUMBER_SUCCESS;
+    }
+    /* check overflow */
+    if (exponent > 125) {
+        return ORANUMBER_NUMERIC_OVERFLOW;
+    }
+    /* change the base number from 10 to 100 */
+    if (idx % 2 == 1) {
+        mantissa[idx++] = 0;
+    }
+    idx /= 2;
+    for (i = 0; i < idx; i++) {
+        mantissa[i] = mantissa[i * 2] * 10 + mantissa[i * 2 + 1];
+    }
+    /* add negative value's terminator */
+    if (!is_positive && idx < 20) {
+        mantissa[idx++] = -1;
+    }
+    /* construct OCINumber */
+    on->ACINumberPart[0] = 1 + idx;
+    if (is_positive) {
+        on->ACINumberPart[1] = (exponent >> 1) + 193;
+        for (i = 0; i < idx; i++) {
+            on->ACINumberPart[i + 2] = mantissa[i] + 1;
+        }
+    } else {
+        on->ACINumberPart[1] = 62 - (exponent >> 1);
+        for (i = 0; i < idx; i++) {
+            on->ACINumberPart[i + 2] = 101 - mantissa[i];
+        }
+    }
+    return ORANUMBER_SUCCESS;
+}
+
+int oranumber_dump(const ACINumber *on, char *buf)
+{
+    int idx;
+    int len = on->ACINumberPart[0];
+    int offset;
+
+    offset = sprintf(buf, "Typ=2 Len=%u: ", len);
+    if (len > 21) {
+        len = 21;
+    }
+    for (idx = 1; idx <= len; idx++) {
+        offset += sprintf(buf + offset, "%u,", (ub4)on->ACINumberPart[idx]);
+    }
+    buf[--offset] = '\0';
+    return offset;
+}

data/ext/oci8/oranumber_util.h

@@ -0,0 +1,24 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/*
+ * oranumber_util.h - part of ruby-oci8
+ *
+ * Copyright (C) 2010 KUBO Takehiro <kubo@jiubao.org>
+ */
+#ifndef ORANUMBER_UTIL_H
+#define ORANUMBER_UTIL_H 1
+#include <aci.h>
+
+#define ORANUMBER_INVALID_INTERNAL_FORMAT -1
+#define ORANUMBER_TOO_SHORT_BUFFER -2
+
+#define ORANUMBER_SUCCESS 0
+#define ORANUMBER_INVALID_NUMBER 1722
+#define ORANUMBER_NUMERIC_OVERFLOW 1426
+
+int oranumber_to_str(const OCINumber *on, char *buf, int buflen);
+int oranumber_from_str(OCINumber *on, const char *buf, int buflen);
+
+#define ORANUMBER_DUMP_BUF_SIZ 99
+int oranumber_dump(const OCINumber *on, char *buf);
+
+#endif

data/ext/oci8/plthook.h

@@ -0,0 +1,66 @@
+/* -*- indent-tabs-mode: nil -*-
+ *
+ * plthook.h -- the header file of plthook
+ *
+ * URL: https://github.com/kubo/plthook
+ *
+ * ------------------------------------------------------
+ *
+ * Copyright 2013-2014 Kubo Takehiro <kubo@jiubao.org>
+ *
+ * Redistribution and use in source and binary forms, with or without modification, are
+ * permitted provided that the following conditions are met:
+ *
+ *    1. Redistributions of source code must retain the above copyright notice, this list of
+ *       conditions and the following disclaimer.
+ *
+ *    2. Redistributions in binary form must reproduce the above copyright notice, this list
+ *       of conditions and the following disclaimer in the documentation and/or other materials
+ *       provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHORS ''AS IS'' AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+ * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * The views and conclusions contained in the software and documentation are those of the
+ * authors and should not be interpreted as representing official policies, either expressed
+ * or implied, of the authors.
+ *
+ */
+#ifndef PLTHOOK_H
+#define PLTHOOK_H 1
+
+#define PLTHOOK_SUCCESS              0
+#define PLTHOOK_FILE_NOT_FOUND       1
+#define PLTHOOK_INVALID_FILE_FORMAT  2
+#define PLTHOOK_FUNCTION_NOT_FOUND   3
+#define PLTHOOK_INVALID_ARGUMENT     4
+#define PLTHOOK_OUT_OF_MEMORY        5
+#define PLTHOOK_INTERNAL_ERROR       6
+#define PLTHOOK_NOT_IMPLEMENTED      7
+
+typedef struct plthook plthook_t;
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+int plthook_open(plthook_t **plthook_out, const char *filename);
+int plthook_open_by_handle(plthook_t **plthook_out, void *handle);
+int plthook_open_by_address(plthook_t **plthook_out, void *address);
+int plthook_enum(plthook_t *plthook, unsigned int *pos, const char **name_out, void ***addr_out);
+int plthook_replace(plthook_t *plthook, const char *funcname, void *funcaddr, void **oldfunc);
+void plthook_close(plthook_t *plthook);
+const char *plthook_error(void);
+
+#ifdef __cplusplus
+}; /* extern "C" */
+#endif
+
+#endif