oj 3.9.1 → 3.16.11

data/ext/oj/resolve.c

@@ -1,102 +1,80 @@
-/* resolve.c
- * Copyright (c) 2012, Peter Ohler
- * All rights reserved.
- */
+// 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>
 #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, VALUE error_class) {
-    char	class_name[1024];
-    VALUE	clas;
-    char	*end = class_name + sizeof(class_name) - 1;
-    char	*s;
-    const char	*n = name;
+static VALUE 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))) {
-	oj_set_error_at(pi, error_class, __FILE__, __LINE__, "class %s is not defined", name);
-	if (Qnil != error_class) {
-	    pi->err_class = error_class;
-	}
+        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 error_class) {
-    VALUE	clas;
-    VALUE	*slot;
-
     if (No == pi->options.class_cache) {
-	return resolve_classpath(pi, name, len, auto_define, error_class);
+        return resolve_classpath(pi, name, len, auto_define, error_class);
     }
-#ifdef HAVE_PTHREAD_MUTEX_INIT
-    pthread_mutex_lock(&oj_cache_mutex);
-#else
-    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, error_class))) {
-	    *slot = clas;
-	}
-    }
-#ifdef HAVE_PTHREAD_MUTEX_INIT
-    pthread_mutex_unlock(&oj_cache_mutex);
-#else
-    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, VALUE error_class) {
-    size_t	len = RSTRING_LEN(nameVal);
-    const char	*str = StringValuePtr(nameVal);
+    size_t      len = RSTRING_LEN(nameVal);
+    const char *str = StringValuePtr(nameVal);
 
     return resolve_classpath(pi, str, len, 0, error_class);
 }

data/ext/oj/resolve.h

@@ -1,14 +1,12 @@
-/* resolve.h
- * Copyright (c) 2011, Peter Ohler
- * All rights reserved.
- */
+// 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
 
 #include "ruby.h"
 
-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);
+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 */

data/ext/oj/rxclass.c

@@ -1,79 +1,77 @@
-/* rxclass.c
- * Copyright (c) 2017, Peter Ohler
- * All rights reserved.
- */
+// Copyright (c) 2017 Peter Ohler. All rights reserved.
+// Licensed under the MIT License. See LICENSE file in the project root for license details.
 
-#include <sys/types.h>
-#include <stdlib.h>
 #include <errno.h>
-#include <string.h>
 #include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/types.h>
 #if !IS_WINDOWS
 #include <regex.h>
 #endif
 
+#include "mem.h"
 #include "rxclass.h"
 
 typedef struct _rxC {
-    struct _rxC	*next;
-    VALUE	rrx;
+    struct _rxC *next;
+    VALUE        rrx;
 #if !IS_WINDOWS
-    regex_t	rx;
+    regex_t rx;
 #endif
-    VALUE	clas;
-    char	src[256];
+    VALUE clas;
+    char  src[256];
 } *RxC;
 
-void
-oj_rxclass_init(RxClass rc) {
+void oj_rxclass_init(RxClass rc) {
     *rc->err = '\0';
     rc->head = NULL;
     rc->tail = NULL;
 }
 
-void
-oj_rxclass_cleanup(RxClass rc) {
-    RxC	rxc;
+void oj_rxclass_cleanup(RxClass rc) {
+    RxC rxc;
 
     while (NULL != (rxc = rc->head)) {
-	rc->head = rc->head->next;
+        rc->head = rc->head->next;
 #if !IS_WINDOWS
-	if (Qnil == rxc->rrx) {
-	    regfree(&rxc->rx);
-	}
-	xfree(rxc);
+        if (Qnil == rxc->rrx) {
+            regfree(&rxc->rx);
+        }
+        OJ_R_FREE(rxc);
 #endif
     }
 }
 
-void
-oj_rxclass_rappend(RxClass rc, VALUE rx, VALUE clas) {
-    RxC	rxc = ALLOC_N(struct _rxC, 1);
+void oj_rxclass_rappend(RxClass rc, VALUE rx, VALUE clas) {
+    RxC rxc = OJ_R_ALLOC_N(struct _rxC, 1);
 
     memset(rxc, 0, sizeof(struct _rxC));
-    rxc->rrx = rx;
+    rxc->rrx  = rx;
     rxc->clas = clas;
     if (NULL == rc->tail) {
-	rc->head = rxc;
+        rc->head = rxc;
     } else {
-	rc->tail->next = rxc;
+        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;
+int oj_rxclass_append(RxClass rc, const char *expr, VALUE clas) {
+    RxC rxc;
 #if !IS_WINDOWS
-    int	err;
-    int	flags = 0;
+    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;
+        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       = OJ_R_ALLOC_N(struct _rxC, 1);
     rxc->next = 0;
     rxc->clas = clas;
 
@@ -82,15 +80,15 @@ oj_rxclass_append(RxClass rc, const char *expr, VALUE clas) {
 #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;
+        regerror(err, &rxc->rx, rc->err, sizeof(rc->err));
+        OJ_FREE(rxc);
+        return err;
     }
 #endif
     if (NULL == rc->tail) {
-	rc->head = rxc;
+        rc->head = rxc;
     } else {
-	rc->tail->next = rxc;
+        rc->tail->next = rxc;
     }
     rc->tail = rxc;
 
@@ -99,49 +97,48 @@ oj_rxclass_append(RxClass rc, const char *expr, VALUE clas) {
 
 VALUE
 oj_rxclass_match(RxClass rc, const char *str, int len) {
-    RxC		rxc;
-    char	buf[4096];
-    
+    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 (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 atempt a match
-	    memcpy(buf, str, len);
-	    buf[len] = '\0';
-	    if (0 == regexec(&rxc->rx, buf, 0, NULL, 0)) { // match
-		return rxc->clas;
-	    }
+            // 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
-	}
+        } else {
+            // TBD allocate a larger buffer and attempt
+        }
     }
     return Qnil;
 }
 
-void
-oj_rxclass_copy(RxClass src, RxClass dest) {
+void oj_rxclass_copy(RxClass src, RxClass dest) {
     dest->head = NULL;
     dest->tail = NULL;
     if (NULL != src->head) {
-	RxC	rxc;
+        RxC rxc;
 
-	for (rxc = src->head; NULL != rxc; rxc = rxc->next) {
-	    if (Qnil != rxc->rrx) {
-		oj_rxclass_rappend(dest, rxc->rrx, rxc->clas);
-	    } else {
+        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);
+                oj_rxclass_append(dest, rxc->src, rxc->clas);
 #endif
-	    }
-	}
+            }
+        }
     }
 }

data/ext/oj/rxclass.h

@@ -1,27 +1,26 @@
-/* rxclass.h
- * Copyright (c) 2017, Peter Ohler
- * All rights reserved.
- */
+// 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];
+    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);
+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 */