js-stream-sas7bdat 0.1.0 → 0.1.1

package/src/binding/ReadStat/src/readstat_bits.h

@@ -0,0 +1,20 @@
+//
+//  readstat_bit.h - Bit-twiddling utility functions
+//
+
+#define READSTAT_MACHINE_IS_TWOS_COMPLEMENT ((char)0xFF == (char)-1)
+
+#undef READSTAT_MACHINE_IS_TWOS_COMPLEMENT
+#define READSTAT_MACHINE_IS_TWOS_COMPLEMENT 0
+
+int machine_is_little_endian(void);
+
+char ones_to_twos_complement1(char num);
+int16_t ones_to_twos_complement2(int16_t num);
+int32_t ones_to_twos_complement4(int32_t num);
+uint16_t byteswap2(uint16_t num);
+uint32_t byteswap4(uint32_t num);
+uint64_t byteswap8(uint64_t num);
+
+float byteswap_float(float num);
+double byteswap_double(double num);

package/src/binding/ReadStat/src/readstat_convert.c

@@ -0,0 +1,36 @@
+
+#include <errno.h>
+#include "readstat.h"
+#include "readstat_iconv.h"
+#include "readstat_convert.h"
+
+readstat_error_t readstat_convert(char *dst, size_t dst_len, const char *src, size_t src_len, iconv_t converter) {
+    /* strip off spaces from the input because the programs use ASCII space
+     * padding even with non-ASCII encoding. */
+    while (src_len && (src[src_len-1] == ' ' || src[src_len-1] == '\0')) {
+        src_len--;
+    }
+    if (dst_len == 0) {
+        return READSTAT_ERROR_CONVERT_LONG_STRING;
+    } else if (converter) {
+        size_t dst_left = dst_len - 1;
+        char *dst_end = dst;
+        size_t status = iconv(converter, (readstat_iconv_inbuf_t)&src, &src_len, &dst_end, &dst_left);
+        if (status == (size_t)-1) {
+            if (errno == E2BIG) {
+                return READSTAT_ERROR_CONVERT_LONG_STRING;
+            } else if (errno == EILSEQ) {
+                return READSTAT_ERROR_CONVERT_BAD_STRING;
+            } else if (errno != EINVAL) { /* EINVAL indicates improper truncation; accept it */
+                return READSTAT_ERROR_CONVERT;
+            }
+        }
+        dst[dst_len - dst_left - 1] = '\0';
+    } else if (src_len + 1 > dst_len) {
+        return READSTAT_ERROR_CONVERT_LONG_STRING;
+    } else {
+        memcpy(dst, src, src_len);
+        dst[src_len] = '\0';
+    }
+    return READSTAT_OK;
+}

package/src/binding/ReadStat/src/readstat_convert.h

@@ -0,0 +1,2 @@
+
+readstat_error_t readstat_convert(char *dst, size_t dst_len, const char *src, size_t src_len, iconv_t converter);

package/src/binding/ReadStat/src/readstat_error.c

@@ -0,0 +1,126 @@
+
+#include "readstat.h"
+
+const char *readstat_error_message(readstat_error_t error_code) {
+    if (error_code == READSTAT_OK)
+        return NULL;
+
+    if (error_code == READSTAT_ERROR_OPEN)
+        return "Unable to open file";
+
+    if (error_code == READSTAT_ERROR_READ)
+        return "Unable to read from file";
+
+    if (error_code == READSTAT_ERROR_MALLOC)
+        return "Unable to allocate memory";
+
+    if (error_code == READSTAT_ERROR_USER_ABORT)
+        return "The parsing was aborted (callback returned non-zero value)";
+
+    if (error_code == READSTAT_ERROR_PARSE)
+        return "Invalid file, or file has unsupported features";
+
+    if (error_code == READSTAT_ERROR_UNSUPPORTED_COMPRESSION)
+        return "File has unsupported compression scheme";
+
+    if (error_code == READSTAT_ERROR_UNSUPPORTED_CHARSET)
+        return "File has an unsupported character set";
+
+    if (error_code == READSTAT_ERROR_COLUMN_COUNT_MISMATCH)
+        return "File did not contain the expected number of columns";
+
+    if (error_code == READSTAT_ERROR_ROW_COUNT_MISMATCH)
+        return "File did not contain the expected number of rows";
+
+    if (error_code == READSTAT_ERROR_ROW_WIDTH_MISMATCH)
+        return "A row in the file was not the expected length";
+
+    if (error_code == READSTAT_ERROR_BAD_FORMAT_STRING)
+        return "A provided format string could not be understood";
+
+    if (error_code == READSTAT_ERROR_VALUE_TYPE_MISMATCH)
+        return "A provided value was incompatible with the variable's declared type";
+
+    if (error_code == READSTAT_ERROR_WRITE)
+        return "Unable to write data";
+    
+    if (error_code == READSTAT_ERROR_WRITER_NOT_INITIALIZED)
+        return "The writer object was not properly initialized (call and check return value of readstat_begin_writing_XXX)";
+
+    if (error_code == READSTAT_ERROR_SEEK)
+        return "Unable to seek within file";
+
+    if (error_code == READSTAT_ERROR_CONVERT)
+        return "Unable to convert string to the requested encoding";
+
+    if (error_code == READSTAT_ERROR_CONVERT_BAD_STRING)
+        return "Unable to convert string to the requested encoding (invalid byte sequence)";
+
+    if (error_code == READSTAT_ERROR_CONVERT_SHORT_STRING)
+        return "Unable to convert string to the requested encoding (incomplete byte sequence)";
+
+    if (error_code == READSTAT_ERROR_CONVERT_LONG_STRING)
+        return "Unable to convert string to the requested encoding (output buffer too small)";
+
+    if (error_code == READSTAT_ERROR_NUMERIC_VALUE_IS_OUT_OF_RANGE)
+        return "A provided numeric value was outside the range of representable values in the specified file format";
+
+    if (error_code == READSTAT_ERROR_TAGGED_VALUE_IS_OUT_OF_RANGE)
+        return "A provided tag value was outside the range of allowed values in the specified file format";
+
+    if (error_code == READSTAT_ERROR_STRING_VALUE_IS_TOO_LONG)
+        return "A provided string value was longer than the available storage size of the specified column";
+
+    if (error_code == READSTAT_ERROR_TAGGED_VALUES_NOT_SUPPORTED)
+        return "The file format does not supported character tags for missing values";
+
+    if (error_code == READSTAT_ERROR_UNSUPPORTED_FILE_FORMAT_VERSION)
+        return "This version of the file format is not supported";
+
+    if (error_code == READSTAT_ERROR_NAME_BEGINS_WITH_ILLEGAL_CHARACTER)
+        return "A provided name begins with an illegal character";
+
+    if (error_code == READSTAT_ERROR_NAME_CONTAINS_ILLEGAL_CHARACTER)
+        return "A provided name contains an illegal character";
+
+    if (error_code == READSTAT_ERROR_NAME_IS_RESERVED_WORD)
+        return "A provided name is a reserved word";
+
+    if (error_code == READSTAT_ERROR_NAME_IS_TOO_LONG)
+        return "A provided name is too long for the file format";
+
+    if (error_code == READSTAT_ERROR_NAME_IS_ZERO_LENGTH)
+        return "A provided name is blank or empty";
+
+    if (error_code == READSTAT_ERROR_BAD_TIMESTAMP_STRING)
+        return "The file's timestamp string is invalid";
+
+    if (error_code == READSTAT_ERROR_BAD_FREQUENCY_WEIGHT)
+        return "The provided variable can't be used as a frequency weight";
+
+    if (error_code == READSTAT_ERROR_TOO_MANY_MISSING_VALUE_DEFINITIONS)
+        return "The number of defined missing values exceeds the format limit";
+
+    if (error_code == READSTAT_ERROR_NOTE_IS_TOO_LONG)
+        return "The provided note is too long for the file format";
+
+    if (error_code == READSTAT_ERROR_STRING_REFS_NOT_SUPPORTED)
+        return "This version of the file format does not support string references";
+
+    if (error_code == READSTAT_ERROR_STRING_REF_IS_REQUIRED)
+        return "The provided value was not a valid string reference";
+
+    if (error_code == READSTAT_ERROR_ROW_IS_TOO_WIDE_FOR_PAGE)
+        return "A row of data will not fit into the file format";
+
+    if (error_code == READSTAT_ERROR_TOO_FEW_COLUMNS)
+        return "One or more columns must be provided";
+
+    if (error_code == READSTAT_ERROR_TOO_MANY_COLUMNS)
+        return "Too many columns for this file format version";
+
+    if (error_code == READSTAT_ERROR_BAD_TIMESTAMP_VALUE)
+        return "The provided file timestamp is invalid";
+
+    return "Unknown error";
+}

package/src/binding/ReadStat/src/readstat_iconv.h

@@ -0,0 +1,15 @@
+#include <iconv.h>
+
+/* ICONV_CONST defined by autotools during configure according
+ * to the current platform. Some people copy-paste the source code, so
+ * provide some fallback logic */
+#ifndef ICONV_CONST
+#define ICONV_CONST
+#endif
+
+typedef ICONV_CONST char ** readstat_iconv_inbuf_t;
+
+typedef struct readstat_charset_entry_s {
+    int     code;
+    char    name[32];
+} readstat_charset_entry_t;

package/src/binding/ReadStat/src/readstat_io_unistd.c

@@ -0,0 +1,147 @@
+
+#include <fcntl.h>
+#include <stdlib.h>
+#include <wchar.h>
+
+#if defined _WIN32
+#   include <windows.h>
+#   include <io.h>
+#endif
+
+#if !defined(_MSC_VER)
+#   include <unistd.h>
+#else
+#define open _open
+#define read _read
+#define close _close
+#endif
+
+#if defined _WIN32 || defined __CYGWIN__
+#define UNISTD_OPEN_OPTIONS O_RDONLY | O_BINARY
+#elif defined _AIX
+#define UNISTD_OPEN_OPTIONS O_RDONLY | O_LARGEFILE
+#else
+#define UNISTD_OPEN_OPTIONS O_RDONLY
+#endif
+
+#if defined _WIN32
+#define lseek _lseeki64
+#elif defined _AIX
+#define lseek lseek64
+#endif
+
+#include "readstat.h"
+#include "readstat_io_unistd.h"
+
+int open_with_unicode(const char *path, int options)
+{
+#if defined _WIN32
+    const int buffer_size = MultiByteToWideChar(CP_UTF8, 0, path, -1, NULL, 0);
+
+    if(buffer_size <= 0)
+        return -1;
+
+    wchar_t* wpath = malloc((buffer_size + 1) * sizeof(wchar_t));
+    const int res = MultiByteToWideChar(CP_UTF8, 0, path, -1, wpath, buffer_size);
+    wpath[buffer_size] = 0;
+
+    if(res <= 0)
+    {
+        free(wpath);
+        return -1;
+    }
+
+    int fd = _wopen(wpath, options);
+
+    free(wpath);
+    return fd;
+#else
+    return open(path, options);
+#endif
+}
+
+int unistd_open_handler(const char *path, void *io_ctx) {
+    int fd = open_with_unicode(path, UNISTD_OPEN_OPTIONS);
+    ((unistd_io_ctx_t*) io_ctx)->fd = fd;
+    return fd;
+}
+
+int unistd_close_handler(void *io_ctx) {
+    int fd = ((unistd_io_ctx_t*) io_ctx)->fd;
+    if (fd != -1)
+        return close(fd);
+    else
+        return 0;
+}
+
+readstat_off_t unistd_seek_handler(readstat_off_t offset,
+        readstat_io_flags_t whence, void *io_ctx) {
+    int flag = 0;
+    switch(whence) {
+        case READSTAT_SEEK_SET:
+            flag = SEEK_SET;
+            break;
+        case READSTAT_SEEK_CUR:
+            flag = SEEK_CUR;
+            break;
+        case READSTAT_SEEK_END:
+            flag = SEEK_END;
+            break;
+        default:
+            return -1;
+    }
+    int fd = ((unistd_io_ctx_t*) io_ctx)->fd;
+    return lseek(fd, offset, flag);
+}
+
+ssize_t unistd_read_handler(void *buf, size_t nbyte, void *io_ctx) {
+    int fd = ((unistd_io_ctx_t*) io_ctx)->fd;
+    ssize_t out = read(fd, buf, nbyte);
+    return out;
+}
+
+readstat_error_t unistd_update_handler(long file_size, 
+        readstat_progress_handler progress_handler, void *user_ctx,
+        void *io_ctx) {
+    if (!progress_handler)
+        return READSTAT_OK;
+
+    int fd = ((unistd_io_ctx_t*) io_ctx)->fd;
+    readstat_off_t current_offset = lseek(fd, 0, SEEK_CUR);
+
+    if (current_offset == -1)
+        return READSTAT_ERROR_SEEK;
+
+    if (progress_handler(1.0 * current_offset / file_size, user_ctx))
+        return READSTAT_ERROR_USER_ABORT;
+
+    return READSTAT_OK;
+}
+
+readstat_error_t unistd_io_init(readstat_parser_t *parser) {
+    readstat_error_t retval = READSTAT_OK;
+    unistd_io_ctx_t *io_ctx = NULL;
+
+    if ((retval = readstat_set_open_handler(parser, unistd_open_handler)) != READSTAT_OK)
+        return retval;
+
+    if ((retval = readstat_set_close_handler(parser, unistd_close_handler)) != READSTAT_OK)
+        return retval;
+
+    if ((retval = readstat_set_seek_handler(parser, unistd_seek_handler)) != READSTAT_OK)
+        return retval;
+
+    if ((retval = readstat_set_read_handler(parser, unistd_read_handler)) != READSTAT_OK)
+        return retval;
+
+    if ((readstat_set_update_handler(parser, unistd_update_handler)) != READSTAT_OK)
+        return retval;
+
+    io_ctx = calloc(1, sizeof(unistd_io_ctx_t));
+    io_ctx->fd = -1;
+
+    retval = readstat_set_io_ctx(parser, (void*) io_ctx);
+    parser->io->io_ctx_needs_free = 1;
+
+    return retval;
+}

package/src/binding/ReadStat/src/readstat_io_unistd.h

@@ -0,0 +1,11 @@
+
+typedef struct unistd_io_ctx_s {
+    int               fd;
+} unistd_io_ctx_t;
+
+int unistd_open_handler(const char *path, void *io_ctx);
+int unistd_close_handler(void *io_ctx);
+readstat_off_t unistd_seek_handler(readstat_off_t offset, readstat_io_flags_t whence, void *io_ctx);
+ssize_t unistd_read_handler(void *buf, size_t nbytes, void *io_ctx);
+readstat_error_t unistd_update_handler(long file_size, readstat_progress_handler progress_handler, void *user_ctx, void *io_ctx);
+readstat_error_t unistd_io_init(readstat_parser_t *parser);

package/src/binding/ReadStat/src/readstat_malloc.c

@@ -0,0 +1,34 @@
+#include <stdlib.h>
+
+#define MAX_MALLOC_SIZE 0x1000000
+/* =16 MiB. Needs to be at least 0x3FF00, i.e. the default ~4MB block size used
+ * in compressed SPSS (ZSAV) files. Some SAS installations use 16MiB page sizes
+ * by default, see https://github.com/tidyverse/haven/issues/697.
+ * The purpose here is to prevent massive allocations in the event of a
+ * malformed file or a bug in the library. */
+
+void *readstat_malloc(size_t len) {
+    if (len > MAX_MALLOC_SIZE || len == 0) {
+        return NULL;
+    }
+    return malloc(len);
+}
+
+void *readstat_calloc(size_t count, size_t size) {
+    if (count > MAX_MALLOC_SIZE || size > MAX_MALLOC_SIZE || count * size > MAX_MALLOC_SIZE) {
+        return NULL;
+    }
+    if (count == 0 || size == 0) {
+        return NULL;
+    }
+    return calloc(count, size);
+}
+
+void *readstat_realloc(void *ptr, size_t len) {
+    if (len > MAX_MALLOC_SIZE || len == 0) {
+        if (ptr)
+            free(ptr);
+        return NULL;
+    }
+    return realloc(ptr, len);
+}

package/src/binding/ReadStat/src/readstat_malloc.h

@@ -0,0 +1,4 @@
+
+void *readstat_malloc(size_t size);
+void *readstat_calloc(size_t count, size_t size);
+void *readstat_realloc(void *ptr, size_t len);

package/src/binding/ReadStat/src/readstat_metadata.c

@@ -0,0 +1,53 @@
+#include "readstat.h"
+
+int readstat_get_row_count(readstat_metadata_t *metadata) {
+    return metadata->row_count;
+}
+
+int readstat_get_var_count(readstat_metadata_t *metadata) {
+    return metadata->var_count;
+}
+
+time_t readstat_get_creation_time(readstat_metadata_t *metadata) {
+    return metadata->creation_time;
+}
+
+time_t readstat_get_modified_time(readstat_metadata_t *metadata) {
+    return metadata->modified_time;
+}
+
+int readstat_get_file_format_version(readstat_metadata_t *metadata) {
+    return metadata->file_format_version;
+}
+
+int readstat_get_file_format_is_64bit(readstat_metadata_t *metadata) {
+    return metadata->is64bit;
+}
+
+readstat_compress_t readstat_get_compression(readstat_metadata_t *metadata) {
+    return metadata->compression;
+}
+
+readstat_endian_t readstat_get_endianness(readstat_metadata_t *metadata) {
+    return metadata->endianness;
+}
+
+const char *readstat_get_file_label(readstat_metadata_t *metadata) {
+    return metadata->file_label;
+}
+
+const char *readstat_get_file_encoding(readstat_metadata_t *metadata) {
+    return metadata->file_encoding;
+}
+
+const char *readstat_get_table_name(readstat_metadata_t *metadata) {
+    return metadata->table_name;
+}
+
+size_t readstat_get_multiple_response_sets_length(readstat_metadata_t *metadata) {
+    return metadata->multiple_response_sets_length;
+}
+
+const mr_set_t *readstat_get_multiple_response_sets(readstat_metadata_t *metadata) {
+    return metadata->mr_sets;
+}

package/src/binding/ReadStat/src/readstat_parser.c

@@ -0,0 +1,121 @@
+
+#include <stdlib.h>
+#include "readstat.h"
+#include "readstat_io_unistd.h"
+
+readstat_parser_t *readstat_parser_init(void) {
+    readstat_parser_t *parser = calloc(1, sizeof(readstat_parser_t));
+    parser->io = calloc(1, sizeof(readstat_io_t));
+    if (unistd_io_init(parser) != READSTAT_OK) {
+        readstat_parser_free(parser);
+        return NULL;
+    }
+    parser->output_encoding = "UTF-8";
+    return parser;
+}
+
+void readstat_parser_free(readstat_parser_t *parser) {
+    if (parser) {
+        if (parser->io) {
+            readstat_set_io_ctx(parser, NULL);
+            free(parser->io);
+        }
+        free(parser);
+    }
+}
+
+readstat_error_t readstat_set_metadata_handler(readstat_parser_t *parser, readstat_metadata_handler metadata_handler) {
+    parser->handlers.metadata = metadata_handler;
+    return READSTAT_OK;
+}
+
+readstat_error_t readstat_set_note_handler(readstat_parser_t *parser, readstat_note_handler note_handler) {
+    parser->handlers.note = note_handler;
+    return READSTAT_OK;
+}
+
+readstat_error_t readstat_set_variable_handler(readstat_parser_t *parser, readstat_variable_handler variable_handler) {
+    parser->handlers.variable = variable_handler;
+    return READSTAT_OK;
+}
+
+readstat_error_t readstat_set_value_handler(readstat_parser_t *parser, readstat_value_handler value_handler) {
+    parser->handlers.value = value_handler;
+    return READSTAT_OK;
+}
+
+readstat_error_t readstat_set_value_label_handler(readstat_parser_t *parser, readstat_value_label_handler label_handler) {
+    parser->handlers.value_label = label_handler;
+    return READSTAT_OK;
+}
+
+readstat_error_t readstat_set_error_handler(readstat_parser_t *parser, readstat_error_handler error_handler) {
+    parser->handlers.error = error_handler;
+    return READSTAT_OK;
+}
+
+readstat_error_t readstat_set_progress_handler(readstat_parser_t *parser, readstat_progress_handler progress_handler) {
+    parser->handlers.progress = progress_handler;
+    return READSTAT_OK;
+}
+
+readstat_error_t readstat_set_fweight_handler(readstat_parser_t *parser, readstat_fweight_handler fweight_handler) {
+    parser->handlers.fweight = fweight_handler;
+    return READSTAT_OK;
+}
+
+readstat_error_t readstat_set_open_handler(readstat_parser_t *parser, readstat_open_handler open_handler) {
+    parser->io->open = open_handler;
+    return READSTAT_OK;
+}
+
+readstat_error_t readstat_set_close_handler(readstat_parser_t *parser, readstat_close_handler close_handler) {
+    parser->io->close = close_handler;
+    return READSTAT_OK;
+}
+
+readstat_error_t readstat_set_seek_handler(readstat_parser_t *parser, readstat_seek_handler seek_handler) {
+    parser->io->seek = seek_handler;
+    return READSTAT_OK;
+}
+
+readstat_error_t readstat_set_read_handler(readstat_parser_t *parser, readstat_read_handler read_handler) {
+    parser->io->read = read_handler;
+    return READSTAT_OK;
+}
+
+readstat_error_t readstat_set_update_handler(readstat_parser_t *parser, readstat_update_handler update_handler) {
+    parser->io->update = update_handler;
+    return READSTAT_OK;
+}
+
+readstat_error_t readstat_set_io_ctx(readstat_parser_t *parser, void *io_ctx) {
+    if (parser->io->io_ctx_needs_free) {
+        free(parser->io->io_ctx);
+    }
+
+    parser->io->io_ctx = io_ctx;
+    parser->io->io_ctx_needs_free = 0;
+
+    return READSTAT_OK;
+}
+
+readstat_error_t readstat_set_file_character_encoding(readstat_parser_t *parser, const char *encoding) {
+    parser->input_encoding = encoding;
+    return READSTAT_OK;
+}
+
+readstat_error_t readstat_set_handler_character_encoding(readstat_parser_t *parser, const char *encoding) {
+    parser->output_encoding = encoding;
+    return READSTAT_OK;
+}
+
+readstat_error_t readstat_set_row_limit(readstat_parser_t *parser, long row_limit) {
+    parser->row_limit = row_limit;
+    return READSTAT_OK;
+}
+
+readstat_error_t readstat_set_row_offset(readstat_parser_t *parser, long row_offset) {
+    parser->row_offset = row_offset;
+    return READSTAT_OK;
+}

package/src/binding/ReadStat/src/readstat_strings.h

@@ -0,0 +1,6 @@
+#if defined(_MSC_VER)
+#   define strncasecmp _strnicmp
+#   define strcasecmp _stricmp
+#else
+#   include <strings.h>
+#endif