oj 2.18.3 → 3.13.14

data/ext/oj/resolve.c

@@ -1,129 +1,81 @@
-/* resolve.c
- * Copyright (c) 2012, Peter Ohler
- * All rights reserved.
- * 
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- * 
- *  - Redistributions of source code must retain the above copyright notice, this
- *    list of conditions and the following disclaimer.
- * 
- *  - 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.
- * 
- *  - Neither the name of Peter Ohler nor the names of its contributors may be
- *    used to endorse or promote products derived from this software without
- *    specific prior written permission.
- * 
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 THE 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.
- */
+// Copyright (c) 2012 Peter Ohler. All rights reserved.
+// Licensed under the MIT License. See LICENSE file in the project root for license details.
 
-#include <stdlib.h>
 #include <stdio.h>
+#include <stdlib.h>
 #include <string.h>
-#if USE_PTHREAD_MUTEX
+#ifdef HAVE_PTHREAD_MUTEX_INIT
 #include <pthread.h>
 #endif
 
-#include "oj.h"
 #include "err.h"
+#include "intern.h"
+#include "oj.h"
 #include "parse.h"
-#include "hash.h"
 
-inline static VALUE
-resolve_classname(VALUE mod, const char *classname, int auto_define) {
-    VALUE	clas;
-    ID		ci = rb_intern(classname);
+inline static VALUE resolve_classname(VALUE mod, const char *classname, int auto_define) {
+    VALUE clas;
+    ID    ci = rb_intern(classname);
 
     if (rb_const_defined_at(mod, ci)) {
-	clas = rb_const_get_at(mod, ci);
+        clas = rb_const_get_at(mod, ci);
     } else if (auto_define) {
-	clas = rb_define_class_under(mod, classname, oj_bag_class);
+        clas = rb_define_class_under(mod, classname, oj_bag_class);
     } else {
-	clas = Qundef;
+        clas = Qundef;
     }
     return clas;
 }
 
 static VALUE
-resolve_classpath(ParseInfo pi, const char *name, size_t len, int auto_define) {
-    char	class_name[1024];
-    VALUE	clas;
-    char	*end = class_name + sizeof(class_name) - 1;
-    char	*s;
-    const char	*n = name;
+resolve_classpath(ParseInfo pi, const char *name, size_t len, int auto_define, VALUE error_class) {
+    char        class_name[1024];
+    VALUE       clas;
+    char *      end = class_name + sizeof(class_name) - 1;
+    char *      s;
+    const char *n = name;
 
     clas = rb_cObject;
     for (s = class_name; 0 < len; n++, len--) {
-	if (':' == *n) {
-	    *s = '\0';
-	    n++;
-	    len--;
-	    if (':' != *n) {
-		return Qundef;
-	    }
-	    if (Qundef == (clas = resolve_classname(clas, class_name, auto_define))) {
-		return Qundef;
-	    }
-	    s = class_name;
-	} else if (end <= s) {
-	    return Qundef;
-	} else {
-	    *s++ = *n;
-	}
+        if (':' == *n) {
+            *s = '\0';
+            n++;
+            len--;
+            if (':' != *n) {
+                return Qundef;
+            }
+            if (Qundef == (clas = resolve_classname(clas, class_name, auto_define))) {
+                return Qundef;
+            }
+            s = class_name;
+        } else if (end <= s) {
+            return Qundef;
+        } else {
+            *s++ = *n;
+        }
     }
     *s = '\0';
     if (Qundef == (clas = resolve_classname(clas, class_name, auto_define))) {
-	if (sizeof(class_name) - 1 < len) {
-	    len = sizeof(class_name) - 1;
-	}
-	memcpy(class_name, name, len);
-	class_name[len] = '\0';
-	oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "class %s is not defined", class_name);
+        oj_set_error_at(pi, error_class, __FILE__, __LINE__, "class %s is not defined", name);
+        if (Qnil != error_class) {
+            pi->err_class = error_class;
+        }
     }
     return clas;
 }
 
 VALUE
-oj_name2class(ParseInfo pi, const char *name, size_t len, int auto_define) {
-    VALUE	clas;
-    VALUE	*slot;
-
+oj_name2class(ParseInfo pi, const char *name, size_t len, int auto_define, VALUE error_class) {
     if (No == pi->options.class_cache) {
-	return resolve_classpath(pi, name, len, auto_define);
+        return resolve_classpath(pi, name, len, auto_define, error_class);
     }
-#if USE_PTHREAD_MUTEX
-    pthread_mutex_lock(&oj_cache_mutex);
-#elif USE_RB_MUTEX
-    rb_mutex_lock(oj_cache_mutex);
-#endif
-    if (Qnil == (clas = oj_class_hash_get(name, len, &slot))) {
-	if (Qundef != (clas = resolve_classpath(pi, name, len, auto_define))) {
-	    *slot = clas;
-	}
-    }
-#if USE_PTHREAD_MUTEX
-    pthread_mutex_unlock(&oj_cache_mutex);
-#elif USE_RB_MUTEX
-    rb_mutex_unlock(oj_cache_mutex);
-#endif
-    return clas;
+    return oj_class_intern(name, len, true, pi, auto_define, error_class);
 }
 
 VALUE
-oj_name2struct(ParseInfo pi, VALUE nameVal) {
-    size_t	len = RSTRING_LEN(nameVal);
-    const char	*str = StringValuePtr(nameVal);
+oj_name2struct(ParseInfo pi, VALUE nameVal, VALUE error_class) {
+    size_t      len = RSTRING_LEN(nameVal);
+    const char *str = StringValuePtr(nameVal);
 
-    return resolve_classpath(pi, str, len, 0);
+    return resolve_classpath(pi, str, len, 0, error_class);
 }

data/ext/oj/resolve.h

@@ -1,39 +1,12 @@
-/* resolve.h
- * Copyright (c) 2011, Peter Ohler
- * All rights reserved.
- * 
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- * 
- *  - Redistributions of source code must retain the above copyright notice, this
- *    list of conditions and the following disclaimer.
- * 
- *  - 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.
- * 
- *  - Neither the name of Peter Ohler nor the names of its contributors may be
- *    used to endorse or promote products derived from this software without
- *    specific prior written permission.
- * 
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 THE 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.
- */
+// 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_RESOLVE_H__
-#define __OJ_RESOLVE_H__
+#ifndef OJ_RESOLVE_H
+#define OJ_RESOLVE_H
 
 #include "ruby.h"
 
-extern VALUE	oj_name2class(ParseInfo pi, const char *name, size_t len, int auto_define);
-extern VALUE	oj_name2struct(ParseInfo pi, VALUE nameVal);
+extern VALUE oj_name2class(ParseInfo pi, const char *name, size_t len, int auto_define, VALUE error_class);
+extern VALUE oj_name2struct(ParseInfo pi, VALUE nameVal, VALUE error_class);
 
-#endif /* __OJ_RESOLVE_H__ */
+#endif /* OJ_RESOLVE_H */

data/ext/oj/rxclass.c

@@ -0,0 +1,143 @@
+// Copyright (c) 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 <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/types.h>
+#if !IS_WINDOWS
+#include <regex.h>
+#endif
+
+#include "rxclass.h"
+
+typedef struct _rxC {
+    struct _rxC *next;
+    VALUE        rrx;
+#if !IS_WINDOWS
+    regex_t rx;
+#endif
+    VALUE clas;
+    char  src[256];
+} * RxC;
+
+void oj_rxclass_init(RxClass rc) {
+    *rc->err = '\0';
+    rc->head = NULL;
+    rc->tail = NULL;
+}
+
+void oj_rxclass_cleanup(RxClass rc) {
+    RxC rxc;
+
+    while (NULL != (rxc = rc->head)) {
+        rc->head = rc->head->next;
+#if !IS_WINDOWS
+        if (Qnil == rxc->rrx) {
+            regfree(&rxc->rx);
+        }
+        xfree(rxc);
+#endif
+    }
+}
+
+void oj_rxclass_rappend(RxClass rc, VALUE rx, VALUE clas) {
+    RxC rxc = ALLOC_N(struct _rxC, 1);
+
+    memset(rxc, 0, sizeof(struct _rxC));
+    rxc->rrx  = rx;
+    rxc->clas = clas;
+    if (NULL == rc->tail) {
+        rc->head = rxc;
+    } else {
+        rc->tail->next = rxc;
+    }
+    rc->tail = rxc;
+}
+
+// Attempt to compile the expression. If it fails populate the error code..
+int oj_rxclass_append(RxClass rc, const char *expr, VALUE clas) {
+    RxC rxc;
+#if !IS_WINDOWS
+    int err;
+    int flags = 0;
+#endif
+    if (sizeof(rxc->src) <= strlen(expr)) {
+        snprintf(rc->err,
+                 sizeof(rc->err),
+                 "expressions must be less than %lu characters",
+                 (unsigned long)sizeof(rxc->src));
+        return EINVAL;
+    }
+    rxc       = ALLOC_N(struct _rxC, 1);
+    rxc->next = 0;
+    rxc->clas = clas;
+
+#if IS_WINDOWS
+    rxc->rrx = rb_funcall(rb_cRegexp, rb_intern("new"), 1, rb_str_new2(expr));
+#else
+    rxc->rrx = Qnil;
+    if (0 != (err = regcomp(&rxc->rx, expr, flags))) {
+        regerror(err, &rxc->rx, rc->err, sizeof(rc->err));
+        free(rxc);
+        return err;
+    }
+#endif
+    if (NULL == rc->tail) {
+        rc->head = rxc;
+    } else {
+        rc->tail->next = rxc;
+    }
+    rc->tail = rxc;
+
+    return 0;
+}
+
+VALUE
+oj_rxclass_match(RxClass rc, const char *str, int len) {
+    RxC  rxc;
+    char buf[4096];
+
+    for (rxc = rc->head; NULL != rxc; rxc = rxc->next) {
+        if (Qnil != rxc->rrx) {
+            // Must use a valiabel for this to work.
+            volatile VALUE rstr = rb_str_new(str, len);
+
+            // if (Qtrue == rb_funcall(rxc->rrx, rb_intern("match?"), 1, rstr)) {
+            if (Qnil != rb_funcall(rxc->rrx, rb_intern("match"), 1, rstr)) {
+                return rxc->clas;
+            }
+        } else if (len < (int)sizeof(buf)) {
+#if !IS_WINDOWS
+            // string is not \0 terminated so copy and attempt a match
+            memcpy(buf, str, len);
+            buf[len] = '\0';
+            if (0 == regexec(&rxc->rx, buf, 0, NULL, 0)) {  // match
+                return rxc->clas;
+            }
+#endif
+        } else {
+            // TBD allocate a larger buffer and attempt
+        }
+    }
+    return Qnil;
+}
+
+void oj_rxclass_copy(RxClass src, RxClass dest) {
+    dest->head = NULL;
+    dest->tail = NULL;
+    if (NULL != src->head) {
+        RxC rxc;
+
+        for (rxc = src->head; NULL != rxc; rxc = rxc->next) {
+            if (Qnil != rxc->rrx) {
+                oj_rxclass_rappend(dest, rxc->rrx, rxc->clas);
+            } else {
+#if !IS_WINDOWS
+                oj_rxclass_append(dest, rxc->src, rxc->clas);
+#endif
+            }
+        }
+    }
+}

data/ext/oj/rxclass.h

@@ -0,0 +1,26 @@
+// Copyright (c) 2017 Peter Ohler. All rights reserved.
+// Licensed under the MIT License. See LICENSE file in the project root for license details.
+
+#ifndef OJ_RXCLASS_H
+#define OJ_RXCLASS_H
+
+#include <stdbool.h>
+
+#include "ruby.h"
+
+struct _rxC;
+
+typedef struct _rxClass {
+    struct _rxC *head;
+    struct _rxC *tail;
+    char         err[128];
+} * RxClass;
+
+extern void  oj_rxclass_init(RxClass rc);
+extern void  oj_rxclass_cleanup(RxClass rc);
+extern int   oj_rxclass_append(RxClass rc, const char *expr, VALUE clas);
+extern VALUE oj_rxclass_match(RxClass rc, const char *str, int len);
+extern void  oj_rxclass_copy(RxClass src, RxClass dest);
+extern void  oj_rxclass_rappend(RxClass rc, VALUE rx, VALUE clas);
+
+#endif /* OJ_RXCLASS_H */