nano-safe-gem 0.0.1

data/oj-3.17.3/ext/oj/dump_strict.c

@@ -0,0 +1,404 @@
+// Copyright (c) 2012, 2017 Peter Ohler. All rights reserved.
+// Licensed under the MIT License. See LICENSE file in the project root for license details.
+
+#include <errno.h>
+#include <math.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+#include <unistd.h>
+
+#include "dump.h"
+#include "trace.h"
+
+// Workaround in case INFINITY is not defined in math.h or if the OS is CentOS
+#define OJ_INFINITY (1.0 / 0.0)
+
+typedef unsigned long ulong;
+
+static const char inf_val[]  = INF_VAL;
+static const char ninf_val[] = NINF_VAL;
+static const char nan_val[]  = NAN_VAL;
+
+static void raise_strict(VALUE obj) {
+    rb_raise(rb_eTypeError, "Failed to dump %s Object to JSON in strict mode.\n", rb_class2name(rb_obj_class(obj)));
+}
+
+// Removed dependencies on math due to problems with CentOS 5.4.
+static void dump_float(VALUE obj, int depth, Out out, bool as_ok) {
+    char   buf[64];
+    char*  b;
+    double d   = rb_num2dbl(obj);
+    size_t cnt = 0;
+
+    if (0.0 == d) {
+        b    = buf;
+        *b++ = '0';
+        *b++ = '.';
+        *b++ = '0';
+        *b++ = '\0';
+        cnt  = 3;
+    } else {
+        NanDump nd = out->opts->dump_opts.nan_dump;
+
+        if (AutoNan == nd) {
+            nd = RaiseNan;
+        }
+        if (OJ_INFINITY == d) {
+            switch (nd) {
+            case RaiseNan:
+            case WordNan: raise_strict(obj); break;
+            case NullNan:
+                strcpy(buf, "null");
+                cnt = 4;
+                break;
+            case HugeNan:
+            default:
+                strcpy(buf, inf_val);
+                cnt = sizeof(inf_val) - 1;
+                break;
+            }
+        } else if (-OJ_INFINITY == d) {
+            switch (nd) {
+            case RaiseNan:
+            case WordNan: raise_strict(obj); break;
+            case NullNan:
+                strcpy(buf, "null");
+                cnt = 4;
+                break;
+            case HugeNan:
+            default:
+                strcpy(buf, ninf_val);
+                cnt = sizeof(ninf_val) - 1;
+                break;
+            }
+        } else if (isnan(d)) {
+            switch (nd) {
+            case RaiseNan:
+            case WordNan: raise_strict(obj); break;
+            case NullNan:
+                strcpy(buf, "null");
+                cnt = 4;
+                break;
+            case HugeNan:
+            default:
+                strcpy(buf, nan_val);
+                cnt = sizeof(nan_val) - 1;
+                break;
+            }
+        } else if (d == (double)(long long int)d) {
+            cnt = snprintf(buf, sizeof(buf), "%.1f", d);
+        } else if (0 == out->opts->float_prec) {
+            volatile VALUE rstr = oj_safe_string_convert(obj);
+
+            cnt = RSTRING_LEN(rstr);
+            if ((int)sizeof(buf) <= cnt) {
+                cnt = sizeof(buf) - 1;
+            }
+            memcpy(buf, RSTRING_PTR(rstr), cnt);
+            buf[cnt] = '\0';
+        } else {
+            cnt = oj_dump_float_printf(buf, sizeof(buf), obj, d, out->opts->float_fmt);
+        }
+    }
+    assure_size(out, cnt);
+    APPEND_CHARS(out->cur, buf, cnt);
+    *out->cur = '\0';
+}
+
+static void dump_array(VALUE a, int depth, Out out, bool as_ok) {
+    size_t size;
+    size_t i;
+    size_t cnt;
+    int    d2 = depth + 1;
+
+    if (Yes == out->opts->circular) {
+        if (0 > oj_check_circular(a, out)) {
+            oj_dump_nil(Qnil, 0, out, false);
+            return;
+        }
+    }
+    cnt         = RARRAY_LEN(a);
+    *out->cur++ = '[';
+    size        = 2;
+    assure_size(out, size);
+    if (0 == cnt) {
+        *out->cur++ = ']';
+    } else {
+        if (out->opts->dump_opts.use) {
+            size = d2 * out->opts->dump_opts.indent_size + out->opts->dump_opts.array_size + 1;
+        } else {
+            size = d2 * out->indent + 2;
+        }
+        assure_size(out, size * cnt);
+        cnt--;
+        for (i = 0; i <= cnt; i++) {
+            if (out->opts->dump_opts.use) {
+                if (0 < out->opts->dump_opts.array_size) {
+                    APPEND_CHARS(out->cur, out->opts->dump_opts.array_nl, out->opts->dump_opts.array_size);
+                }
+                if (0 < out->opts->dump_opts.indent_size) {
+                    int i;
+                    for (i = d2; 0 < i; i--) {
+                        APPEND_CHARS(out->cur, out->opts->dump_opts.indent_str, out->opts->dump_opts.indent_size);
+                    }
+                }
+            } else {
+                fill_indent(out, d2);
+            }
+            if (NullMode == out->opts->mode) {
+                oj_dump_null_val(RARRAY_AREF(a, i), d2, out);
+            } else {
+                oj_dump_strict_val(RARRAY_AREF(a, i), d2, out);
+            }
+            if (i < cnt) {
+                *out->cur++ = ',';
+            }
+        }
+        size = depth * out->indent + 1;
+        assure_size(out, size);
+        if (out->opts->dump_opts.use) {
+            // printf("*** d2: %u  indent: %u '%s'\n", d2, out->opts->dump_opts->indent_size,
+            // out->opts->dump_opts->indent);
+            if (0 < out->opts->dump_opts.array_size) {
+                APPEND_CHARS(out->cur, out->opts->dump_opts.array_nl, out->opts->dump_opts.array_size);
+            }
+            if (0 < out->opts->dump_opts.indent_size) {
+                int i;
+
+                for (i = depth; 0 < i; i--) {
+                    APPEND_CHARS(out->cur, out->opts->dump_opts.indent_str, out->opts->dump_opts.indent_size);
+                }
+            }
+        } else {
+            fill_indent(out, depth);
+        }
+        *out->cur++ = ']';
+    }
+    *out->cur = '\0';
+}
+
+static int hash_cb(VALUE key, VALUE value, VALUE ov) {
+    Out  out   = (Out)ov;
+    int  depth = out->depth;
+    long size;
+    int  rtype = rb_type(key);
+
+    if (rtype != T_STRING && rtype != T_SYMBOL) {
+        rb_raise(rb_eTypeError,
+                 "In :strict and :null mode all Hash keys must be Strings or Symbols, not %s.\n",
+                 rb_class2name(rb_obj_class(key)));
+    }
+    if (out->omit_nil && Qnil == value) {
+        return ST_CONTINUE;
+    }
+    if (NULL != out->opts->dump_opts.only || NULL != out->opts->dump_opts.except) {
+        if (oj_key_skip(key, out->opts->dump_opts.only, out->opts->dump_opts.except)) {
+            return ST_CONTINUE;
+        }
+    }
+    if (!out->opts->dump_opts.use) {
+        size = depth * out->indent + 1;
+        assure_size(out, size);
+        fill_indent(out, depth);
+        switch (rtype) {
+        case T_STRING: oj_dump_str(key, 0, out, false); break;
+        case T_SYMBOL: oj_dump_sym(key, 0, out, false); break;
+        default: oj_dump_str(oj_safe_string_convert(key), 0, out, false); break;
+        }
+        *out->cur++ = ':';
+    } else {
+        size = depth * out->opts->dump_opts.indent_size + out->opts->dump_opts.hash_size + 1;
+        assure_size(out, size);
+        if (0 < out->opts->dump_opts.hash_size) {
+            APPEND_CHARS(out->cur, out->opts->dump_opts.hash_nl, out->opts->dump_opts.hash_size);
+        }
+        if (0 < out->opts->dump_opts.indent_size) {
+            int i;
+            for (i = depth; 0 < i; i--) {
+                APPEND_CHARS(out->cur, out->opts->dump_opts.indent_str, out->opts->dump_opts.indent_size);
+            }
+        }
+        switch (rtype) {
+        case T_STRING: oj_dump_str(key, 0, out, false); break;
+        case T_SYMBOL: oj_dump_sym(key, 0, out, false); break;
+        default: oj_dump_str(oj_safe_string_convert(key), 0, out, false); break;
+        }
+        size = out->opts->dump_opts.before_size + out->opts->dump_opts.after_size + 2;
+        assure_size(out, size);
+        if (0 < out->opts->dump_opts.before_size) {
+            APPEND_CHARS(out->cur, out->opts->dump_opts.before_sep, out->opts->dump_opts.before_size);
+        }
+        *out->cur++ = ':';
+        if (0 < out->opts->dump_opts.after_size) {
+            APPEND_CHARS(out->cur, out->opts->dump_opts.after_sep, out->opts->dump_opts.after_size);
+        }
+    }
+    if (NullMode == out->opts->mode) {
+        oj_dump_null_val(value, depth, out);
+    } else {
+        oj_dump_strict_val(value, depth, out);
+    }
+    out->depth  = depth;
+    *out->cur++ = ',';
+
+    return ST_CONTINUE;
+}
+
+static void dump_hash(VALUE obj, int depth, Out out, bool as_ok) {
+    int    cnt;
+    size_t size;
+
+    if (Yes == out->opts->circular) {
+        if (0 > oj_check_circular(obj, out)) {
+            oj_dump_nil(Qnil, 0, out, false);
+            return;
+        }
+    }
+    cnt  = (int)RHASH_SIZE(obj);
+    size = depth * out->indent + 2;
+    assure_size(out, 2);
+    *out->cur++ = '{';
+    if (0 == cnt) {
+        *out->cur++ = '}';
+    } else {
+        out->depth = depth + 1;
+        rb_hash_foreach(obj, hash_cb, (VALUE)out);
+        if (',' == *(out->cur - 1)) {
+            out->cur--;  // backup to overwrite last comma
+        }
+        if (!out->opts->dump_opts.use) {
+            assure_size(out, size);
+            fill_indent(out, depth);
+        } else {
+            size = depth * out->opts->dump_opts.indent_size + out->opts->dump_opts.hash_size + 1;
+            assure_size(out, size);
+            if (0 < out->opts->dump_opts.hash_size) {
+                APPEND_CHARS(out->cur, out->opts->dump_opts.hash_nl, out->opts->dump_opts.hash_size);
+            }
+            if (0 < out->opts->dump_opts.indent_size) {
+                int i;
+
+                for (i = depth; 0 < i; i--) {
+                    APPEND_CHARS(out->cur, out->opts->dump_opts.indent_str, out->opts->dump_opts.indent_size);
+                }
+            }
+        }
+        *out->cur++ = '}';
+    }
+    *out->cur = '\0';
+}
+
+static void dump_data_strict(VALUE obj, int depth, Out out, bool as_ok) {
+    VALUE clas = rb_obj_class(obj);
+
+    if (oj_bigdecimal_class == clas) {
+        volatile VALUE rstr = oj_safe_string_convert(obj);
+
+        oj_dump_raw(RSTRING_PTR(rstr), RSTRING_LEN(rstr), out);
+    } else {
+        raise_strict(obj);
+    }
+}
+
+static void dump_data_null(VALUE obj, int depth, Out out, bool as_ok) {
+    VALUE clas = rb_obj_class(obj);
+
+    if (oj_bigdecimal_class == clas) {
+        volatile VALUE rstr = oj_safe_string_convert(obj);
+
+        oj_dump_raw(RSTRING_PTR(rstr), RSTRING_LEN(rstr), out);
+    } else {
+        oj_dump_nil(Qnil, depth, out, false);
+    }
+}
+
+static DumpFunc strict_funcs[] = {
+    NULL,              // RUBY_T_NONE   = 0x00,
+    dump_data_strict,  // RUBY_T_OBJECT = 0x01,
+    NULL,              // RUBY_T_CLASS  = 0x02,
+    NULL,              // RUBY_T_MODULE = 0x03,
+    dump_float,        // RUBY_T_FLOAT  = 0x04,
+    oj_dump_str,       // RUBY_T_STRING = 0x05,
+    NULL,              // RUBY_T_REGEXP = 0x06,
+    dump_array,        // RUBY_T_ARRAY  = 0x07,
+    dump_hash,         // RUBY_T_HASH   = 0x08,
+    NULL,              // RUBY_T_STRUCT = 0x09,
+    oj_dump_bignum,    // RUBY_T_BIGNUM = 0x0a,
+    NULL,              // RUBY_T_FILE   = 0x0b,
+    dump_data_strict,  // RUBY_T_DATA   = 0x0c,
+    NULL,              // RUBY_T_MATCH  = 0x0d,
+    NULL,              // RUBY_T_COMPLEX  = 0x0e,
+    NULL,              // RUBY_T_RATIONAL = 0x0f,
+    NULL,              // 0x10
+    oj_dump_nil,       // RUBY_T_NIL    = 0x11,
+    oj_dump_true,      // RUBY_T_TRUE   = 0x12,
+    oj_dump_false,     // RUBY_T_FALSE  = 0x13,
+    oj_dump_sym,       // RUBY_T_SYMBOL = 0x14,
+    oj_dump_fixnum,    // RUBY_T_FIXNUM = 0x15,
+};
+
+void oj_dump_strict_val(VALUE obj, int depth, Out out) {
+    int type = rb_type(obj);
+
+    TRACE(out->opts->trace, "dump", obj, depth, TraceIn);
+    if (MAX_DEPTH < depth) {
+        rb_raise(rb_eNoMemError, "Too deeply nested.\n");
+    }
+    if (0 < type && type <= RUBY_T_FIXNUM) {
+        DumpFunc f = strict_funcs[type];
+
+        if (NULL != f) {
+            f(obj, depth, out, false);
+            TRACE(out->opts->trace, "dump", obj, depth, TraceOut);
+            return;
+        }
+    }
+    raise_strict(obj);
+}
+
+static DumpFunc null_funcs[] = {
+    NULL,            // RUBY_T_NONE   = 0x00,
+    dump_data_null,  // RUBY_T_OBJECT = 0x01,
+    NULL,            // RUBY_T_CLASS  = 0x02,
+    NULL,            // RUBY_T_MODULE = 0x03,
+    dump_float,      // RUBY_T_FLOAT  = 0x04,
+    oj_dump_str,     // RUBY_T_STRING = 0x05,
+    NULL,            // RUBY_T_REGEXP = 0x06,
+    dump_array,      // RUBY_T_ARRAY  = 0x07,
+    dump_hash,       // RUBY_T_HASH   = 0x08,
+    NULL,            // RUBY_T_STRUCT = 0x09,
+    oj_dump_bignum,  // RUBY_T_BIGNUM = 0x0a,
+    NULL,            // RUBY_T_FILE   = 0x0b,
+    dump_data_null,  // RUBY_T_DATA   = 0x0c,
+    NULL,            // RUBY_T_MATCH  = 0x0d,
+    NULL,            // RUBY_T_COMPLEX  = 0x0e,
+    NULL,            // RUBY_T_RATIONAL = 0x0f,
+    NULL,            // 0x10
+    oj_dump_nil,     // RUBY_T_NIL    = 0x11,
+    oj_dump_true,    // RUBY_T_TRUE   = 0x12,
+    oj_dump_false,   // RUBY_T_FALSE  = 0x13,
+    oj_dump_sym,     // RUBY_T_SYMBOL = 0x14,
+    oj_dump_fixnum,  // RUBY_T_FIXNUM = 0x15,
+};
+
+void oj_dump_null_val(VALUE obj, int depth, Out out) {
+    int type = rb_type(obj);
+
+    TRACE(out->opts->trace, "dump", obj, depth, TraceOut);
+    if (MAX_DEPTH < depth) {
+        rb_raise(rb_eNoMemError, "Too deeply nested.\n");
+    }
+    if (0 < type && type <= RUBY_T_FIXNUM) {
+        DumpFunc f = null_funcs[type];
+
+        if (NULL != f) {
+            f(obj, depth, out, false);
+            TRACE(out->opts->trace, "dump", obj, depth, TraceOut);
+            return;
+        }
+    }
+    oj_dump_nil(Qnil, depth, out, false);
+    TRACE(out->opts->trace, "dump", Qnil, depth, TraceOut);
+}

data/oj-3.17.3/ext/oj/encode.h

@@ -0,0 +1,16 @@
+// Copyright (c) 2011 Peter Ohler. All rights reserved.
+// Licensed under the MIT License. See LICENSE file in the project root for license details.
+
+#ifndef OJ_ENCODE_H
+#define OJ_ENCODE_H
+
+#include "oj.h"
+#include "ruby.h"
+#include "ruby/encoding.h"
+
+static inline VALUE oj_encode(VALUE rstr) {
+    rb_enc_associate(rstr, oj_utf8_encoding);
+    return rstr;
+}
+
+#endif /* OJ_ENCODE_H */

data/oj-3.17.3/ext/oj/encoder.c

@@ -0,0 +1,43 @@
+// Copyright (c) 2011, 2022 Peter Ohler. All rights reserved.
+// Licensed under the MIT License. See LICENSE file in the project root for license details.
+
+#include "oj.h"
+
+typedef struct _encoder {
+    int              indent;         // indention for dump, default 2
+    char             circular;       // YesNo
+    char             escape_mode;    // Escape_Mode
+    char             mode;           // Mode
+    char             time_format;    // TimeFormat
+    char             bigdec_as_num;  // YesNo
+    char             to_hash;        // YesNo
+    char             to_json;        // YesNo
+    char             as_json;        // YesNo
+    char             raw_json;       // YesNo
+    char             trace;          // YesNo
+    char             sec_prec_set;   // boolean (0 or 1)
+    char             ignore_under;   // YesNo - ignore attrs starting with _ if true in object and custom modes
+    int64_t          int_range_min;  // dump numbers below as string
+    int64_t          int_range_max;  // dump numbers above as string
+    const char*      create_id;      // 0 or string
+    size_t           create_id_len;  // length of create_id
+    int              sec_prec;       // second precision when dumping time
+    char             float_prec;     // float precision, linked to float_fmt
+    char             float_fmt[7];   // float format for dumping, if empty use Ruby
+    struct _dumpOpts dump_opts;
+    struct _rxClass  str_rx;
+    VALUE*           ignore;  // Qnil terminated array of classes or NULL
+}* Encoder;
+
+/*
+    rb_define_module_function(Oj, "encode", encode, -1);
+    rb_define_module_function(Oj, "to_file", to_file, -1); // or maybe just write
+    rb_define_module_function(Oj, "to_stream", to_stream, -1);
+*/
+
+// write(to, obj)
+//  if to is a string then open file
+//  else if stream then write to stream
+//  handle non-blocking
+
+// should each mode have a different encoder or use delegates like the parser?

data/oj-3.17.3/ext/oj/err.c

@@ -0,0 +1,57 @@
+// Copyright (c) 2011 Peter Ohler. All rights reserved.
+// Licensed under the MIT License. See LICENSE file in the project root for license details.
+
+#include "err.h"
+
+#include <stdarg.h>
+
+void oj_err_set(Err e, VALUE clas, const char *format, ...) {
+    va_list ap;
+
+    va_start(ap, format);
+    e->clas = clas;
+    vsnprintf(e->msg, sizeof(e->msg) - 1, format, ap);
+    va_end(ap);
+}
+
+void oj_err_raise(Err e) {
+    rb_raise(e->clas, "%s", e->msg);
+}
+
+void _oj_err_set_with_location(Err         err,
+                               VALUE       eclas,
+                               const char *msg,
+                               const char *json,
+                               const char *current,
+                               const char *file,
+                               int         line) {
+    int n   = 1;
+    int col = 1;
+
+    for (; json < current && '\n' != *current; current--) {
+        col++;
+    }
+    for (; json < current; current--) {
+        if ('\n' == *current) {
+            n++;
+        }
+    }
+    oj_err_set(err, eclas, "%s at line %d, column %d [%s:%d]", msg, n, col, file, line);
+}
+
+void _oj_raise_error(const char *msg, const char *json, const char *current, const char *file, int line) {
+    struct _err err;
+    int         n   = 1;
+    int         col = 1;
+
+    for (; json < current && '\n' != *current; current--) {
+        col++;
+    }
+    for (; json < current; current--) {
+        if ('\n' == *current) {
+            n++;
+        }
+    }
+    oj_err_set(&err, oj_parse_error_class, "%s at line %d, column %d [%s:%d]", msg, n, col, file, line);
+    rb_raise(err.clas, "%s", err.msg);
+}

data/oj-3.17.3/ext/oj/err.h

@@ -0,0 +1,67 @@
+// Copyright (c) 2011 Peter Ohler. All rights reserved.
+// Licensed under the MIT License. See LICENSE file in the project root for license details.
+
+#ifndef OJ_ERR_H
+#define OJ_ERR_H
+
+#include <errno.h>
+
+#include "ruby.h"
+
+// Needed to silence 2.4.0 warnings.
+#ifndef NORETURN
+#define NORETURN(x) x
+#endif
+
+#define OJ_ERR_START 300
+
+typedef enum {
+    OJ_OK         = 0,
+    OJ_ERR_MEMORY = ENOMEM,
+    OJ_ERR_PARSE  = OJ_ERR_START,
+    OJ_ERR_READ,
+    OJ_ERR_WRITE,
+    OJ_ERR_OVERFLOW,
+    OJ_ERR_ARG,
+    OJ_ERR_TOO_MANY,
+    OJ_ERR_TYPE,
+    OJ_ERR_KEY,
+    OJ_ABORT,
+    OJ_ERR_LAST,
+} ojStatus;
+
+#define set_error(err, eclas, msg, json, current) _oj_err_set_with_location(err, eclas, msg, json, current, FILE, LINE)
+
+typedef struct _err {
+    VALUE clas;
+    char  msg[128];
+} *Err;
+
+extern VALUE oj_parse_error_class;
+
+extern void oj_err_set(Err e, VALUE clas, const char *format, ...);
+extern void _oj_err_set_with_location(Err         err,
+                                      VALUE       eclas,
+                                      const char *msg,
+                                      const char *json,
+                                      const char *current,
+                                      const char *file,
+                                      int         line);
+
+NORETURN(extern void oj_err_raise(Err e));
+
+#define raise_error(msg, json, current) _oj_raise_error(msg, json, current, __FILE__, __LINE__)
+
+NORETURN(
+    extern void _oj_raise_error(const char *msg, const char *json, const char *current, const char *file, int line));
+
+inline static void err_init(Err e) {
+    e->clas = Qnil;
+    *e->msg = '\0';
+}
+
+inline static int err_has(Err e) {
+    return (Qnil != e->clas);
+}
+
+#endif /* OJ_ERR_H */

data/oj-3.17.3/ext/oj/extconf.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require 'mkmf'
+require 'rbconfig'
+
+extension_name = 'oj'
+dir_config(extension_name)
+
+parts = RUBY_DESCRIPTION.split(' ')
+type = parts[0]
+type = type[4..] if type.start_with?('tcs-')
+is_windows = RbConfig::CONFIG['host_os'] =~ /(mingw|mswin)/
+platform = RUBY_PLATFORM
+version = RUBY_VERSION.split('.')
+puts ">>>>> Creating Makefile for #{type} version #{RUBY_VERSION} on #{platform} <<<<<"
+
+dflags = {
+  'RUBY_TYPE' => type,
+  (type.upcase + '_RUBY') => nil,
+  'RUBY_VERSION' => RUBY_VERSION,
+  'RUBY_VERSION_MAJOR' => version[0],
+  'RUBY_VERSION_MINOR' => version[1],
+  'RUBY_VERSION_MICRO' => version[2],
+  'IS_WINDOWS' => is_windows ? 1 : 0,
+  'RSTRUCT_LEN_RETURNS_INTEGER_OBJECT' => ('ruby' == type && '2' == version[0] && '4' == version[1] && '1' >= version[2]) ? 1 : 0,
+}
+
+# Support for compaction.
+have_func('rb_gc_mark_movable')
+have_func('stpcpy')
+have_func('pthread_mutex_init')
+have_func('getrlimit', 'sys/resource.h')
+have_func('rb_enc_interned_str')
+have_func('rb_ext_ractor_safe', 'ruby.h')
+
+dflags['OJ_DEBUG'] = true unless ENV['OJ_DEBUG'].nil?
+
+# SIMD optimizations use runtime CPU detection and function-level target attributes
+# We do NOT add global -msse4.2/-msse2 flags here because:
+# 1. It would cause illegal instruction errors on CPUs without SSE4.2
+# 2. The code uses __attribute__((target("sse4.2"))) for SSE4.2 functions
+# 3. Runtime detection in oj_get_simd_implementation() selects the right path
+#
+# We only add -msse2 if available, since SSE2 is baseline for all x86_64 CPUs
+# and needed for compiling the SSE2 fallback code on 32-bit x86
+if try_cflags('-msse2')
+  $CPPFLAGS += ' -msse2'
+end
+
+if enable_config('trace-log', false)
+  dflags['OJ_ENABLE_TRACE_LOG'] = 1
+end
+
+dflags.each do |k, v|
+  if v.nil?
+    $CPPFLAGS += " -D#{k}"
+  else
+    $CPPFLAGS += " -D#{k}=#{v}"
+  end
+end
+
+$CPPFLAGS += ' -Wall'
+# puts "*** $CPPFLAGS: #{$CPPFLAGS}"
+# Adding the __attribute__ flag only works with gcc compilers and even then it
+# does not work to check args with varargs so just remove the check.
+CONFIG['warnflags'].slice!(/ -Wsuggest-attribute=format/)
+CONFIG['warnflags'].slice!(/ -Wdeclaration-after-statement/)
+CONFIG['warnflags'].slice!(/ -Wmissing-noreturn/)
+
+create_makefile(File.join(extension_name, extension_name))
+
+%x{make clean}