js-stream-sas7bdat 0.1.0 → 0.1.2

package/src/binding/ReadStat/src/sas/readstat_sas_rle.c

@@ -0,0 +1,286 @@
+
+#include <sys/types.h>
+#include <string.h>
+#include <stdio.h>
+
+#if defined(_MSC_VER)
+#include <BaseTsd.h>
+typedef SSIZE_T ssize_t;
+#endif
+
+#include "readstat_sas_rle.h"
+
+#define SAS_RLE_COMMAND_COPY64          0
+#define SAS_RLE_COMMAND_COPY64_PLUS_4096 1
+#define SAS_RLE_COMMAND_COPY96          2
+#define SAS_RLE_COMMAND_INSERT_BYTE18   4
+#define SAS_RLE_COMMAND_INSERT_AT17     5
+#define SAS_RLE_COMMAND_INSERT_BLANK17  6
+#define SAS_RLE_COMMAND_INSERT_ZERO17   7
+#define SAS_RLE_COMMAND_COPY1           8
+#define SAS_RLE_COMMAND_COPY17          9
+#define SAS_RLE_COMMAND_COPY33         10
+#define SAS_RLE_COMMAND_COPY49         11
+#define SAS_RLE_COMMAND_INSERT_BYTE3   12
+#define SAS_RLE_COMMAND_INSERT_AT2     13
+#define SAS_RLE_COMMAND_INSERT_BLANK2  14
+#define SAS_RLE_COMMAND_INSERT_ZERO2   15
+
+#define MAX_INSERT_RUN 4112 // 4095 + 17
+#define MAX_COPY_RUN 4159 // 4095 + 64
+
+static size_t command_lengths[16] = {
+    [SAS_RLE_COMMAND_COPY64] = 1,
+    [SAS_RLE_COMMAND_COPY64_PLUS_4096] = 1,
+    [SAS_RLE_COMMAND_INSERT_BYTE18] = 2,
+    [SAS_RLE_COMMAND_INSERT_AT17] = 1,
+    [SAS_RLE_COMMAND_INSERT_BLANK17] = 1,
+    [SAS_RLE_COMMAND_INSERT_ZERO17] = 1,
+    [SAS_RLE_COMMAND_INSERT_BYTE3] = 1
+};
+
+ssize_t sas_rle_decompressed_len(const void *input_buf, size_t input_len) {
+    return sas_rle_decompress(NULL, 0, input_buf, input_len);
+}
+
+ssize_t sas_rle_decompress(void *output_buf, size_t output_len, 
+        const void *input_buf, size_t input_len) {
+    unsigned char *buffer = (unsigned char *)output_buf;
+    unsigned char *output = buffer;
+    size_t output_written = 0;
+
+    const unsigned char *input = (const unsigned char *)input_buf;
+
+    while (input < (const unsigned char *)input_buf + input_len) {
+        unsigned char control = *input++;
+        unsigned char command = (control & 0xF0) >> 4;
+        unsigned char length = (control & 0x0F);
+        int copy_len = 0;
+        int insert_len = 0;
+        unsigned char insert_byte = '\0';
+        if (input + command_lengths[command] > (const unsigned char *)input_buf + input_len) {
+            return -1;
+        }
+        switch (command) {
+            case SAS_RLE_COMMAND_COPY64:
+                copy_len = (*input++) + 64 + length * 256;
+                break;
+            case SAS_RLE_COMMAND_COPY64_PLUS_4096:
+                copy_len = (*input++) + 64 + length * 256 + 4096;
+                break;
+            case SAS_RLE_COMMAND_COPY96: copy_len = length + 96; break;
+            case SAS_RLE_COMMAND_INSERT_BYTE18:
+                insert_len = (*input++) + 18 + length * 256;
+                insert_byte = *input++;
+                break;
+            case SAS_RLE_COMMAND_INSERT_AT17:
+                insert_len = (*input++) + 17 + length * 256;
+                insert_byte = '@';
+                break;
+            case SAS_RLE_COMMAND_INSERT_BLANK17:
+                insert_len = (*input++) + 17 + length * 256;
+                insert_byte = ' ';
+                break;
+            case SAS_RLE_COMMAND_INSERT_ZERO17:
+                insert_len = (*input++) + 17 + length * 256;
+                insert_byte = '\0';
+                break;
+            case SAS_RLE_COMMAND_COPY1:  copy_len = length + 1; break;
+            case SAS_RLE_COMMAND_COPY17: copy_len = length + 17; break;
+            case SAS_RLE_COMMAND_COPY33: copy_len = length + 33; break;
+            case SAS_RLE_COMMAND_COPY49: copy_len = length + 49; break;
+            case SAS_RLE_COMMAND_INSERT_BYTE3:
+                insert_byte = *input++;
+                insert_len = length + 3;
+                break;
+            case SAS_RLE_COMMAND_INSERT_AT2:
+                insert_byte = '@';
+                insert_len = length + 2;
+                break;
+            case SAS_RLE_COMMAND_INSERT_BLANK2:
+                insert_byte = ' ';
+                insert_len = length + 2;
+                break;
+            case SAS_RLE_COMMAND_INSERT_ZERO2:
+                insert_byte = '\0';
+                insert_len = length + 2;
+                break;
+            default:
+                /* error out here? */
+                break;
+        }
+        if (copy_len) {
+            if (output_written + copy_len > output_len) {
+                return -1;
+            }
+            if (input + copy_len > (const unsigned char *)input_buf + input_len) {
+                return -1;
+            }
+            if (output) {
+                memcpy(&output[output_written], input, copy_len);
+            }
+            input += copy_len;
+            output_written += copy_len;
+        }
+        if (insert_len) {
+            if (output_written + insert_len > output_len) {
+                return -1;
+            }
+            if (output) {
+                memset(&output[output_written], insert_byte, insert_len);
+            }
+            output_written += insert_len;
+        }
+    }
+
+    return output_written;
+}
+
+static size_t sas_rle_measure_copy_run(size_t copy_run) {
+    size_t len = 0;
+    while (copy_run >= MAX_COPY_RUN) {
+        len += 2 + MAX_COPY_RUN;
+        copy_run -= MAX_COPY_RUN;
+    }
+    return len + (copy_run > 64) + (copy_run > 0) + copy_run;
+}
+
+static size_t sas_rle_copy_run(unsigned char *output_buf, size_t offset,
+        const unsigned char *copy, size_t copy_run) {
+    unsigned char *out = output_buf + offset;
+    if (output_buf == NULL)
+        return sas_rle_measure_copy_run(copy_run);
+
+    while (copy_run >= MAX_COPY_RUN) {
+        *out++ = (SAS_RLE_COMMAND_COPY64 << 4) + 0x0F;
+        *out++ = 0xFF;
+        memcpy(out, copy, MAX_COPY_RUN);
+        out += MAX_COPY_RUN;
+        copy += MAX_COPY_RUN;
+        copy_run -= MAX_COPY_RUN;
+    }
+
+    if (copy_run > 64) {
+        int length = (copy_run - 64) / 256;
+        unsigned char rem = (copy_run - 64) % 256;
+        *out++ = (SAS_RLE_COMMAND_COPY64 << 4) + (length & 0x0F);
+        *out++ = rem;
+    } else if (copy_run >= 49) {
+        *out++ = (SAS_RLE_COMMAND_COPY49 << 4) + (copy_run - 49);
+    } else if (copy_run >= 33) {
+        *out++ = (SAS_RLE_COMMAND_COPY33 << 4) + (copy_run - 33);
+    } else if (copy_run >= 17) {
+        *out++ = (SAS_RLE_COMMAND_COPY17 << 4) + (copy_run - 17);
+    } else if (copy_run >= 1) {
+        *out++ = (SAS_RLE_COMMAND_COPY1 << 4) + (copy_run - 1);
+    }
+    memcpy(out, copy, copy_run);
+    out += copy_run;
+    return out - (output_buf + offset);
+}
+
+static int sas_rle_is_special_byte(unsigned char last_byte) {
+    return (last_byte == '@' || last_byte == ' ' || last_byte == '\0');
+}
+
+static size_t sas_rle_measure_insert_run(unsigned char last_byte, size_t insert_run) {
+    if (sas_rle_is_special_byte(last_byte))
+        return insert_run > 17 ? 2 : 1;
+
+    return insert_run > 18 ? 3 : 2;
+}
+
+static size_t sas_rle_insert_run(unsigned char *output_buf, size_t offset, unsigned char last_byte, size_t insert_run) {
+    unsigned char *out = output_buf + offset;
+    if (output_buf == NULL)
+        return sas_rle_measure_insert_run(last_byte, insert_run);
+
+    if (sas_rle_is_special_byte(last_byte)) {
+        if (insert_run > 17) {
+            int length = (insert_run - 17) / 256;
+            unsigned char rem = (insert_run - 17) % 256;
+            if (last_byte == '@') {
+                *out++ = (SAS_RLE_COMMAND_INSERT_AT17 << 4) + (length & 0x0F);
+            } else if (last_byte == ' ') {
+                *out++ = (SAS_RLE_COMMAND_INSERT_BLANK17 << 4) + (length & 0x0F);
+            } else if (last_byte == '\0') {
+                *out++ = (SAS_RLE_COMMAND_INSERT_ZERO17 << 4) + (length & 0x0F);
+            }
+            *out++ = rem;
+        } else if (insert_run >= 2) {
+            if (last_byte == '@') {
+                *out++ = (SAS_RLE_COMMAND_INSERT_AT2 << 4) + (insert_run - 2);
+            } else if (last_byte == ' ') {
+                *out++ = (SAS_RLE_COMMAND_INSERT_BLANK2 << 4) + (insert_run - 2);
+            } else if (last_byte == '\0') {
+                *out++ = (SAS_RLE_COMMAND_INSERT_ZERO2 << 4) + (insert_run - 2);
+            }
+        }
+    } else if (insert_run > 18) {
+        int length = (insert_run - 18) / 256;
+        unsigned char rem = (insert_run - 18) % 256;
+        *out++ = (SAS_RLE_COMMAND_INSERT_BYTE18 << 4) + (length & 0x0F);
+        *out++ = rem;
+        *out++ = last_byte;
+    } else if (insert_run >= 3) {
+        *out++ = (SAS_RLE_COMMAND_INSERT_BYTE3 << 4) + (insert_run - 3);
+        *out++ = last_byte;
+    }
+    return out - (output_buf + offset);
+}
+
+static int sas_rle_is_insert_run(unsigned char last_byte, size_t insert_run) {
+    if (sas_rle_is_special_byte(last_byte))
+        return (insert_run > 1);
+
+    return (insert_run > 2);
+}
+
+ssize_t sas_rle_compressed_len(const void *bytes, size_t len) {
+    return sas_rle_compress(NULL, 0, bytes, len);
+}
+
+ssize_t sas_rle_compress(void *output_buf, size_t output_len,
+        const void *input_buf, size_t input_len) {
+    /* TODO bounds check */
+    const unsigned char *p = (const unsigned char *)input_buf;
+    const unsigned char *pe = p + input_len;
+    const unsigned char *copy = p;
+
+    unsigned char *out = (unsigned char *)output_buf;
+
+    size_t insert_run = 0;
+    size_t copy_run = 0;
+    size_t out_written = 0;
+    unsigned char last_byte = 0;
+
+    while (p < pe) {
+        unsigned char c = *p;
+        if (insert_run == 0) {
+            insert_run = 1;
+        } else if (c == last_byte && insert_run < MAX_INSERT_RUN) {
+            insert_run++;
+        } else {
+            if (sas_rle_is_insert_run(last_byte, insert_run)) {
+                out_written += sas_rle_copy_run(out, out_written, copy, copy_run);
+                out_written += sas_rle_insert_run(out, out_written, last_byte, insert_run);
+                copy_run = 0;
+                copy = p;
+            } else {
+                copy_run += insert_run;
+            }
+            insert_run = 1;
+        }
+        last_byte = c;
+        p++;
+    }
+
+    if (sas_rle_is_insert_run(last_byte, insert_run)) {
+        out_written += sas_rle_copy_run(out, out_written, copy, copy_run);
+        out_written += sas_rle_insert_run(out, out_written, last_byte, insert_run);
+    } else {
+        out_written += sas_rle_copy_run(out, out_written, copy, copy_run + insert_run);
+    }
+
+    return out_written;
+}

package/src/binding/ReadStat/src/sas/readstat_sas_rle.h

@@ -0,0 +1,8 @@
+
+ssize_t sas_rle_decompress(void *output_buf, size_t output_len,
+        const void *input_buf, size_t input_len);
+ssize_t sas_rle_compress(void *output_buf, size_t output_len,
+        const void *input_buf, size_t input_len);
+
+ssize_t sas_rle_decompressed_len(const void *input_buf, size_t input_len);
+ssize_t sas_rle_compressed_len(const void *bytes, size_t len);

package/src/binding/ReadStat/src/sas/readstat_xport.c

@@ -0,0 +1,28 @@
+#include <stdint.h>
+
+#include "readstat_xport.h"
+#include "../readstat_bits.h"
+
+char _xport_months[12][4] = {
+    "JAN", "FEB", "MAR", "APR", "MAY", "JUN",
+    "JUL", "AUG", "SEP", "OCT", "NOV", "DEC" };
+
+void xport_namestr_bswap(xport_namestr_t *namestr) {
+    if (!machine_is_little_endian())
+        return;
+
+    namestr->ntype = byteswap2(namestr->ntype);
+    namestr->nhfun = byteswap2(namestr->nhfun);
+    namestr->nlng = byteswap2(namestr->nlng);
+    namestr->nvar0 = byteswap2(namestr->nvar0);
+
+    namestr->nfl = byteswap2(namestr->nfl);
+    namestr->nfd = byteswap2(namestr->nfd);
+    namestr->nfj = byteswap2(namestr->nfj);
+
+    namestr->nifl = byteswap2(namestr->nifl);
+    namestr->nifd = byteswap2(namestr->nifd);
+    namestr->npos = byteswap4(namestr->npos);
+
+    namestr->labeln  = byteswap2(namestr->labeln);
+}

package/src/binding/ReadStat/src/sas/readstat_xport.h

@@ -0,0 +1,47 @@
+
+typedef struct xport_header_record_s {
+    char    name[9];
+
+    int     num1;
+    int     num2;
+    int     num3;
+    int     num4;
+    int     num5;
+    int     num6;
+} xport_header_record_t;
+
+extern char _xport_months[12][4];
+
+#pragma pack(push, 1)
+typedef struct xport_namestr_s {
+    uint16_t    ntype;
+    uint16_t    nhfun;
+    uint16_t    nlng;
+    uint16_t    nvar0;
+    char        nname[8];
+    char        nlabel[40];
+    char        nform[8];
+    uint16_t    nfl;
+    uint16_t    nfd;
+    uint16_t    nfj;
+    char        nfill[2];
+    char        niform[8];
+    uint16_t    nifl;
+    uint16_t    nifd;
+    uint32_t    npos;
+    char        longname[32];
+    uint16_t    labeln;
+    char        rest[18];
+} xport_namestr_t;
+#pragma pack(pop)
+
+typedef struct xport_format_s {
+    char         name[32];
+    int          width;
+    int          decimals;
+} xport_format_t;
+
+#define XPORT_MIN_DOUBLE_SIZE   3
+#define XPORT_MAX_DOUBLE_SIZE   8
+
+void xport_namestr_bswap(xport_namestr_t *namestr);

package/src/binding/ReadStat/src/sas/readstat_xport_parse_format.c

@@ -0,0 +1,265 @@
+
+#line 1 "src/sas/readstat_xport_parse_format.rl"
+
+#include "../readstat.h"
+#include "readstat_xport.h"
+#include "readstat_xport_parse_format.h"
+
+
+#line 10 "src/sas/readstat_xport_parse_format.c"
+static const char _xport_format_parse_actions[] = {
+	0, 1, 0, 1, 1, 1, 3, 1, 
+	4, 2, 2, 0, 3, 1, 2, 0
+	
+};
+
+static const char _xport_format_parse_key_offsets[] = {
+	0, 0, 7, 14, 23, 31, 31, 34, 
+	42, 50, 58, 60, 62, 65, 73, 81
+};
+
+static const char _xport_format_parse_trans_keys[] = {
+	95, 48, 57, 65, 90, 97, 122, 95, 
+	48, 57, 65, 90, 97, 122, 36, 46, 
+	95, 48, 57, 65, 90, 97, 122, 46, 
+	95, 48, 57, 65, 90, 97, 122, 46, 
+	48, 57, 46, 95, 48, 57, 65, 90, 
+	97, 122, 46, 95, 48, 57, 65, 90, 
+	97, 122, 46, 95, 48, 57, 65, 90, 
+	97, 122, 48, 57, 48, 57, 46, 48, 
+	57, 46, 95, 48, 57, 65, 90, 97, 
+	122, 46, 95, 48, 57, 65, 90, 97, 
+	122, 46, 95, 48, 57, 65, 90, 97, 
+	122, 0
+};
+
+static const char _xport_format_parse_single_lengths[] = {
+	0, 1, 1, 3, 2, 0, 1, 2, 
+	2, 2, 0, 0, 1, 2, 2, 2
+};
+
+static const char _xport_format_parse_range_lengths[] = {
+	0, 3, 3, 3, 3, 0, 1, 3, 
+	3, 3, 1, 1, 1, 3, 3, 3
+};
+
+static const char _xport_format_parse_index_offsets[] = {
+	0, 0, 5, 10, 17, 23, 24, 27, 
+	33, 39, 45, 47, 49, 52, 58, 64
+};
+
+static const char _xport_format_parse_indicies[] = {
+	2, 0, 2, 2, 1, 4, 3, 4, 
+	4, 1, 5, 6, 8, 7, 8, 8, 
+	1, 9, 11, 10, 11, 11, 1, 1, 
+	12, 13, 1, 9, 0, 14, 0, 0, 
+	1, 12, 2, 15, 2, 2, 1, 9, 
+	2, 14, 2, 2, 1, 16, 1, 17, 
+	1, 18, 19, 1, 6, 3, 20, 3, 
+	3, 1, 18, 4, 21, 4, 4, 1, 
+	6, 4, 20, 4, 4, 1, 0
+};
+
+static const char _xport_format_parse_trans_targs[] = {
+	1, 0, 9, 2, 15, 4, 10, 12, 
+	13, 5, 6, 7, 5, 6, 8, 8, 
+	11, 11, 10, 12, 14, 14
+};
+
+static const char _xport_format_parse_trans_actions[] = {
+	0, 0, 0, 0, 0, 0, 3, 12, 
+	0, 3, 12, 0, 5, 1, 12, 1, 
+	9, 1, 5, 1, 12, 1
+};
+
+static const char _xport_format_parse_eof_actions[] = {
+	0, 0, 0, 3, 3, 0, 5, 3, 
+	5, 3, 0, 7, 5, 3, 5, 3
+};
+
+static const int xport_format_parse_start = 3;
+
+static const int xport_format_parse_en_main = 3;
+
+
+#line 9 "src/sas/readstat_xport_parse_format.rl"
+
+
+readstat_error_t xport_parse_format(const char *data, size_t len, xport_format_t *fmt,
+        readstat_error_handler error_handler, void *user_ctx) {
+
+    fmt->name[0] = '\0';
+    fmt->width = 0;
+    fmt->decimals = 0;
+
+    readstat_error_t retval = READSTAT_OK;
+    const char *p = data;
+    const char *pe = p + len;
+    const char *eof = pe;
+
+    int cs;
+    unsigned int temp_val = 0;
+    size_t parsed_len = 0;
+
+    
+#line 106 "src/sas/readstat_xport_parse_format.c"
+	{
+	cs = xport_format_parse_start;
+	}
+
+#line 111 "src/sas/readstat_xport_parse_format.c"
+	{
+	int _klen;
+	unsigned int _trans;
+	const char *_acts;
+	unsigned int _nacts;
+	const char *_keys;
+
+	if ( p == pe )
+		goto _test_eof;
+	if ( cs == 0 )
+		goto _out;
+_resume:
+	_keys = _xport_format_parse_trans_keys + _xport_format_parse_key_offsets[cs];
+	_trans = _xport_format_parse_index_offsets[cs];
+
+	_klen = _xport_format_parse_single_lengths[cs];
+	if ( _klen > 0 ) {
+		const char *_lower = _keys;
+		const char *_mid;
+		const char *_upper = _keys + _klen - 1;
+		while (1) {
+			if ( _upper < _lower )
+				break;
+
+			_mid = _lower + ((_upper-_lower) >> 1);
+			if ( (*p) < *_mid )
+				_upper = _mid - 1;
+			else if ( (*p) > *_mid )
+				_lower = _mid + 1;
+			else {
+				_trans += (unsigned int)(_mid - _keys);
+				goto _match;
+			}
+		}
+		_keys += _klen;
+		_trans += _klen;
+	}
+
+	_klen = _xport_format_parse_range_lengths[cs];
+	if ( _klen > 0 ) {
+		const char *_lower = _keys;
+		const char *_mid;
+		const char *_upper = _keys + (_klen<<1) - 2;
+		while (1) {
+			if ( _upper < _lower )
+				break;
+
+			_mid = _lower + (((_upper-_lower) >> 1) & ~1);
+			if ( (*p) < _mid[0] )
+				_upper = _mid - 2;
+			else if ( (*p) > _mid[1] )
+				_lower = _mid + 2;
+			else {
+				_trans += (unsigned int)((_mid - _keys)>>1);
+				goto _match;
+			}
+		}
+		_trans += _klen;
+	}
+
+_match:
+	_trans = _xport_format_parse_indicies[_trans];
+	cs = _xport_format_parse_trans_targs[_trans];
+
+	if ( _xport_format_parse_trans_actions[_trans] == 0 )
+		goto _again;
+
+	_acts = _xport_format_parse_actions + _xport_format_parse_trans_actions[_trans];
+	_nacts = (unsigned int) *_acts++;
+	while ( _nacts-- > 0 )
+	{
+		switch ( *_acts++ )
+		{
+	case 0:
+#line 28 "src/sas/readstat_xport_parse_format.rl"
+	{
+            temp_val = 10 * temp_val + ((*p) - '0');
+        }
+	break;
+	case 1:
+#line 32 "src/sas/readstat_xport_parse_format.rl"
+	{
+            parsed_len = p - data;
+            if (parsed_len < sizeof(fmt->name)) {
+                memcpy(fmt->name, data, parsed_len);
+                fmt->name[parsed_len] = '\0';
+            }
+        }
+	break;
+	case 2:
+#line 40 "src/sas/readstat_xport_parse_format.rl"
+	{ temp_val = 0; }
+	break;
+	case 3:
+#line 47 "src/sas/readstat_xport_parse_format.rl"
+	{ fmt->width = temp_val; }
+	break;
+#line 209 "src/sas/readstat_xport_parse_format.c"
+		}
+	}
+
+_again:
+	if ( cs == 0 )
+		goto _out;
+	if ( ++p != pe )
+		goto _resume;
+	_test_eof: {}
+	if ( p == eof )
+	{
+	const char *__acts = _xport_format_parse_actions + _xport_format_parse_eof_actions[cs];
+	unsigned int __nacts = (unsigned int) *__acts++;
+	while ( __nacts-- > 0 ) {
+		switch ( *__acts++ ) {
+	case 1:
+#line 32 "src/sas/readstat_xport_parse_format.rl"
+	{
+            parsed_len = p - data;
+            if (parsed_len < sizeof(fmt->name)) {
+                memcpy(fmt->name, data, parsed_len);
+                fmt->name[parsed_len] = '\0';
+            }
+        }
+	break;
+	case 3:
+#line 47 "src/sas/readstat_xport_parse_format.rl"
+	{ fmt->width = temp_val; }
+	break;
+	case 4:
+#line 48 "src/sas/readstat_xport_parse_format.rl"
+	{ fmt->decimals = temp_val; }
+	break;
+#line 243 "src/sas/readstat_xport_parse_format.c"
+		}
+	}
+	}
+
+	_out: {}
+	}
+
+#line 54 "src/sas/readstat_xport_parse_format.rl"
+
+
+    if (cs < 3|| p != pe || parsed_len + 1 > sizeof(fmt->name)) {
+        char error_buf[1024];
+        if (error_handler) {
+            snprintf(error_buf, sizeof(error_buf), "Invalid format string (length=%d): %.*s", (int)len, (int)len, data);
+            error_handler(error_buf, user_ctx);
+        }
+        retval = READSTAT_ERROR_BAD_FORMAT_STRING;
+    }
+
+    (void)xport_format_parse_en_main;
+
+    return retval;
+}

package/src/binding/ReadStat/src/sas/readstat_xport_parse_format.h

@@ -0,0 +1,4 @@
+
+readstat_error_t xport_parse_format(const char *data, size_t len, xport_format_t *fmt,
+        readstat_error_handler error_handler, void *user_ctx);
+

package/src/binding/ReadStat/src/sas/readstat_xport_parse_format.rl

@@ -0,0 +1,68 @@
+
+#include "../readstat.h"
+#include "readstat_xport.h"
+#include "readstat_xport_parse_format.h"
+
+%%{
+    machine xport_format_parse;
+    write data nofinal noerror;
+}%%
+
+readstat_error_t xport_parse_format(const char *data, size_t len, xport_format_t *fmt,
+        readstat_error_handler error_handler, void *user_ctx) {
+
+    fmt->name[0] = '\0';
+    fmt->width = 0;
+    fmt->decimals = 0;
+
+    readstat_error_t retval = READSTAT_OK;
+    const char *p = data;
+    const char *pe = p + len;
+    const char *eof = pe;
+
+    int cs;
+    unsigned int temp_val = 0;
+    size_t parsed_len = 0;
+
+    %%{
+        action incr_val {
+            temp_val = 10 * temp_val + (fc - '0');
+        }
+
+        action write_name {
+            parsed_len = p - data;
+            if (parsed_len < sizeof(fmt->name)) {
+                memcpy(fmt->name, data, parsed_len);
+                fmt->name[parsed_len] = '\0';
+            }
+        }
+
+        integer = [0-9]+ >{ temp_val = 0; } $incr_val;
+
+        name = [A-Za-z_] ([A-Za-z0-9_]+ [A-Za-z_a])?;
+
+        char_name = '$' name? %write_name;
+        dbl_name = name? %write_name;
+
+        width = integer %{ fmt->width = temp_val; };
+        decimals = integer %{ fmt->decimals = temp_val; };
+
+        main := (char_name width? '.'?) | (dbl_name? (width? ('.' decimals?)?)?);
+
+        write init;
+        write exec;
+    }%%
+
+    if (cs < %%{ write first_final; }%%|| p != pe || parsed_len + 1 > sizeof(fmt->name)) {
+        char error_buf[1024];
+        if (error_handler) {
+            snprintf(error_buf, sizeof(error_buf), "Invalid format string (length=%d): %.*s", (int)len, (int)len, data);
+            error_handler(error_buf, user_ctx);
+        }
+        retval = READSTAT_ERROR_BAD_FORMAT_STRING;
+    }
+
+    (void)xport_format_parse_en_main;
+
+    return retval;
+}