oj_windows 3.16.15 → 3.17.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 608dd07735fb09d340eac0f8adc2d9bce84cf1b0bfea863f74ef9c5ff26dd322
-  data.tar.gz: 11920df4ad7ba7696f979c35aa54ce383d5855b99c07e9449aa7a1c6f62ba6d3
+  metadata.gz: ed00cf974105c81c2e38ca66a5a00bcf6d6e32106764537fdbc58264cf96912f
+  data.tar.gz: c9440ab13621b80ffa95fef72a56c02dc362c1282172c6676d5445b53a6a1648
 SHA512:
-  metadata.gz: 1975faac825fcf5dd9f851829dcbea96e4f0487a678161841f630a3a97a4f3acceadedfbbbc379ac01642c0c2d08c3a60f8a7f405f4f5c5fb1a02c097cf12d64
-  data.tar.gz: 249dbbe5e901655c192c94453aac166f45af7da6d84effbaf40935ce262d6346ffbe81cf78085f0491fafa35cd01ca0131bb0184f658f416faaebf3b8b61a4f1
+  metadata.gz: bb72bfd23933e0e0dbe2e2e58f9a6eb6855fca6f5832f3e1b5b7abb7f716dd618f6dbf90150d539677cbb03f6ba76f523b25a60aabc6f02a691cdc9a2e05e821
+  data.tar.gz: 7e7bfc7b9376a3ab6fb164ce8c0d85d10faed4ab9dd63d5ee455311aa3f293f8f3640b4dd6146d2c32368fd29f7b924dcd788b06616832de7c0333ebb51f71ee

data/CHANGELOG.md

@@ -2,6 +2,79 @@
 
 All notable changes to `oj_windows` will be documented in this file.
 
+## [3.17.2.1] - 2026-05-29
+
+Fork revision based on upstream Oj 3.17.2. The version is `3.17.2.1` (not plain
+`3.17.2`) because this carries upstream's parser feature set through 3.17.2 plus
+the MSVC/SIMD adaptations below; it is not a byte-identical rebase of 3.17.2.
+
+### Performance
+- Enabled SIMD string scanning under MSVC. `simd.h` previously gated SSE on the
+  GCC/Clang `__SSE2__`/`__SSE4_2__` feature macros, which `cl.exe` never defines,
+  so the scalar scanner was always used on the only supported platform. SSE2 is
+  now enabled by default on x86_64 (~20–25% faster parsing on string-heavy
+  payloads). Added MSVC shims for the GCC builtins used by the SSE scanners
+  (`__builtin_prefetch`/`__builtin_expect`/`__builtin_ctz`).
+- The SSE4.2 (PCMPESTRI) scanner is also compiled and selectable, but SSE2 is the
+  default because PCMPESTRI is slower on common microarchitectures.
+- Added a `--disable-simd` build option and an `OJ_SCAN=scalar|sse2|sse42` runtime
+  override (replacing the previously non-functional `--with-sse42` flag).
+
+### Security / robustness (ported from upstream Oj 3.16.16–3.17.2)
+- `Oj::Parser` (the "usual" parser) now validates that the document is complete:
+  incomplete literals (`tru`, `nul`, `n`, …) and unclosed arrays/objects (`[1,2`,
+  `{"a":1`) are rejected instead of being silently accepted. Ported upstream's
+  `validate_document_end` (raises `EncodingError`/`Oj::ParserError` with
+  "expected …" / "… is not closed"). `test_parser_usual.rb#test_nil` was updated
+  to match the stricter, upstream behavior.
+- Added the **`Oj::Parser.safe`** parser (upstream 3.17.0): builds Ruby objects
+  like `:usual` but enforces configurable limits on untrusted input —
+  `:max_hash_size`, `:max_array_size`, `:max_depth`, `:max_total_elements` —
+  raising `Oj::Parser::ValidationError` subclasses (`HashSizeError`,
+  `ArraySizeError`, `DepthError`, `TotalElementsError`). Ported `safe.c`/`safe.h`.
+- Added the upstream 3.17.2 "extreme sizes" key-length guard: object keys longer
+  than 32,000 bytes now raise instead of overflowing the `int16_t` key length.
+- Fixed an uninitialized-pointer dereference in the streaming parser: `sparse.c`
+  never set `ni.pi`, but `oj_num_as_value` dereferences `ni->pi->err_class` on the
+  invalid-float path. Initialized `ni.pi` at all three number sites (matches
+  upstream).
+- Note: the non-Windows file-read partial-read fix (#1004) is not reachable on
+  MSVC (that path is `#if !IS_WINDOWS`); the Windows-reachable `Oj::Parser#file`
+  read was fixed separately (see below).
+
+### Fixed
+- `mem.c` (the `MEM_DEBUG` allocator) no longer fails to compile on MSVC: it now
+  uses a Windows `SRWLOCK` (which has a static initializer) instead of an
+  unguarded `pthread_mutex_t`.
+- `Oj::Parser#file` captured the `read()` result in an unsigned `size_t`; on a
+  read error (`-1`) this wrapped to `SIZE_MAX`, causing an out-of-bounds write
+  and making the error branch unreachable. It now uses a signed count, handles
+  errors/EOF correctly, and closes the file descriptor.
+- Guarded the remaining unconditional `<sys/types.h>` includes (`reader.c`,
+  `rxclass.c`) and added a guarded `ssize_t` fallback for MSVC.
+
+### Changed
+- Removed the dead, byte-identical `lib/oj/` duplicate tree from the gem package;
+  `lib/oj_windows/` is the only tree that is ever loaded.
+- gemspec now credits Peter Ohler and states the relationship to upstream Oj
+  (oj_windows replaces, and cannot be co-installed with, the `oj` gem).
+- Build scripts (`package_install.bat`, `compile.bat`, `build_install.bat`) locate
+  Visual Studio via `vswhere` (and put the Installer dir on PATH so vcvars runs
+  cleanly) and derive the gem filename from `Oj::VERSION` instead of hardcoding a
+  VS path or version number.
+- Added a GitHub Actions CI workflow (`.github/workflows/ci.yml`) using the mswin
+  (MSVC) Ruby: it compiles the extension, runs the core test suite, and verifies a
+  clean `gem install` against the Ruby headers alone.
+- `extconf.rb` no longer runs `nmake clean`/`make clean` after `create_makefile`
+  (it ran during `gem install`, just before the build, so it was pointless noise).
+- README: honest performance framing, a CI badge in place of the static
+  "373 Passing"/"High Performance" badges, and corrected test/skip counts (5 skips).
+
+## [3.16.15] - 2025-12-20
+
+- Published release following 3.16.14. This entry was added retroactively to
+  document the version that was actually shipped to RubyGems.
+
 ## [3.16.14] - 2025-12-20
 
 ### Initial Release

data/README.md

@@ -1,164 +1,168 @@
-# oj_windows
-
-**A Windows-native, high-performance JSON parser and Object marshaller for Ruby.**
-
-[![Gem Version](https://img.shields.io/gem/v/oj_windows.svg)](https://rubygems.org/gems/oj_windows)
-
-## Overview
-
-`oj_windows` is a production-ready, Windows-exclusive fork optimized for the **Ruby 3.4.8 MSVC** environment. All POSIX-specific code has been removed or replaced with native Windows equivalents, ensuring maximum performance and stability on Windows systems.
-
-## Requirements
-
-| Component | Version |
-|-----------|---------|
-| Ruby | 3.4.8+ (MSVC build) |
-| OS | Windows 10/11 x64 |
-| Compiler | Visual Studio 2022+ |
-| Architecture | x64-mswin64_140 |
-
-## Installation
-
-```powershell
-gem install oj_windows
-```
-
-Or in your Gemfile:
-
-```ruby
-gem 'oj_windows'
-```
-
-## Quick Start
-
-```ruby
-require 'oj_windows'
-
-# Dump Ruby objects to JSON
-hash = { 'name' => 'oj_windows', 'version' => '3.16.14', 'windows' => true }
-json = Oj.dump(hash)
-# => {"name":"oj_windows","version":"3.16.14","windows":true}
-
-# Load JSON back to Ruby objects  
-data = Oj.load(json)
-# => {"name"=>"oj_windows", "version"=>"3.16.14", "windows"=>true}
-
-# Pretty print
-puts Oj.dump(hash, indent: 2)
-```
-
-## Features
-
-- **High Performance**: Optimized C extension compiled with MSVC
-- **Multiple Modes**: Strict, Compat, Object, Custom, Rails, WAB, Null
-- **JSON Gem Compatibility**: Drop-in replacement via `Oj.mimic_JSON`
-- **Rails Integration**: Full ActiveSupport/ActiveRecord support
-- **Streaming**: SAJ and SC parsers for large documents
-- **StringWriter/StreamWriter**: Efficient JSON generation
-
-## Test Results
-
-All tests pass on Windows MSVC Ruby 3.4.8:
-
-| Test Suite | Runs | Assertions | Failures | Errors | Skips |
-|------------|------|------------|----------|--------|-------|
-| test_various.rb | 69 | 8,202 | 0 | 0 | 1 |
-| test_strict.rb | 42 | 71 | 0 | 0 | 0 |
-| test_compat.rb | 55 | 112 | 0 | 0 | 0 |
-| test_object.rb | 74 | 160 | 0 | 0 | 0 |
-| test_fast.rb | 43 | 137 | 0 | 0 | 0 |
-| test_saj.rb | 13 | 18 | 0 | 0 | 0 |
-| test_scp.rb | 23 | 23 | 0 | 0 | 2 |
-| test_gc.rb | 3 | 50 | 0 | 0 | 0 |
-| test_writer.rb | 27 | 28 | 0 | 0 | 1 |
-| test_file.rb | 21 | 52 | 0 | 0 | 1 |
-| test_hash.rb | 3 | 7 | 0 | 0 | 0 |
-| **Total** | **373** | **8,860** | **0** | **0** | **6** |
-
-> **Note**: The 6 skipped tests are fork-based operations that are not supported on Windows. This is expected behavior.
-
-## Performance Benchmarks
-
-Benchmarks run on Windows with Ruby 3.4.8 MSVC (50,000 iterations):
-
-### Parse Performance
-| Parser | Ops/sec |
-|--------|---------|
-| JSON::Ext | 444,501 |
-| Oj:wab | 402,185 |
-| Oj:strict | 380,664 |
-
-### Dump Performance  
-| Dumper | Ops/sec |
-|--------|---------|
-| JSON::Ext | 832,994 |
-| Oj:strict | 816,299 |
-
-> **\*** In synthetic benchmarks with simple data structures, Ruby's native `JSON::Ext` may appear faster because it is tightly integrated with the Ruby VM. However, `oj_windows` provides significant advantages:
-> - **Object mode**: Full Ruby object serialization/deserialization (not possible with JSON gem)
-> - **Rails/ActiveSupport**: Optimized `as_json`/`to_json` integration
-> - **Streaming parsers**: SAJ and SCP for memory-efficient parsing of large documents
-> - **Circular references**: Automatic detection and handling
-> - **Custom behaviors**: Fine-grained control over serialization
->
-> For complex real-world applications with deep object graphs, custom types, and Rails integration, `oj_windows` remains the optimal choice.
-
-## Modes
-
-| Mode | Description |
-|------|-------------|
-| `:strict` | Strict JSON compliance, only native types |
-| `:compat` | Compatible with the JSON gem |
-| `:object` | Full Ruby object serialization |
-| `:custom` | Customizable serialization behavior |
-| `:rails` | Rails and ActiveSupport compatibility |
-| `:wab` | WAB (Web Application Builder) format |
-| `:null` | Return null for unsupported types |
-
-## Configuration
-
-```ruby
-# Set default options
-Oj.default_options = {
-  mode: :compat,
-  symbol_keys: true,
-  indent: 2
-}
-
-# Check current options
-Oj.default_options
-```
-
-## Documentation
-
-- [Options](pages/Options.md) - Parse and dump options
-- [Modes](pages/Modes.md) - Detailed mode documentation
-- [Rails](pages/Rails.md) - Rails integration guide
-- [JsonGem](pages/JsonGem.md) - JSON gem compatibility
-- [Advanced](pages/Advanced.md) - Advanced features
-
-## Building from Source
-
-```powershell
-# Requires MSVC environment
-call "C:\Program Files\Microsoft Visual Studio\2022\Community\VC\Auxiliary\Build\vcvars64.bat"
-
-# Build and install
-.\package_install.bat
-```
-
-## Running Tests
-
-```powershell
-cd test
-.\test_all_no_rails.bat
-```
-
-## License
-
-MIT License - See [LICENSE](LICENSE) for details.
-
----
-
-*Version 3.16.14 - December 2025*
-*Original OJ https://github.com/ohler55/oj*
+# oj_windows
+
+**A Windows-native, high-performance JSON parser and Object marshaller for Ruby.**
+
+[![Gem Version](https://img.shields.io/gem/v/oj_windows.svg?style=flat-square)](https://rubygems.org/gems/oj_windows)
+[![Ruby](https://img.shields.io/badge/Ruby-3.4%2B-CC342D?style=flat-square&logo=ruby&logoColor=white)](https://www.ruby-lang.org/)
+[![Platform](https://img.shields.io/badge/Platform-Windows%20MSVC-0078D6?style=flat-square&logo=windows&logoColor=white)](https://github.com/tigel-agm/oj_windows)
+[![License](https://img.shields.io/badge/License-MIT-green?style=flat-square)](https://github.com/tigel-agm/oj_windows/blob/main/LICENSE)
+[![CI](https://github.com/tigel-agm/oj_windows/actions/workflows/ci.yml/badge.svg)](https://github.com/tigel-agm/oj_windows/actions/workflows/ci.yml)
+
+## Overview
+
+`oj_windows` is a fork of [Oj](https://github.com/ohler55/oj) by Peter Ohler, adapted to build with the **MSVC (mswin)** Ruby toolchain. POSIX-specific code has been guarded or replaced with native Windows equivalents (pthread mutexes → Windows synchronization, `timegm` → `_mkgmtime`, guarded POSIX headers), and SIMD string scanning is enabled under MSVC.
+
+> **Relationship to upstream Oj.** Almost all of this code is Peter Ohler's. `oj_windows` exists only to provide a buildable Oj for Ruby compiled with the MSVC toolchain. It defines the same `Oj` module and the same public API, so **it is a drop-in replacement for — and cannot be installed alongside — the upstream `oj` gem**. If you use the standard **RubyInstaller / MinGW** Ruby, install the upstream [`oj`](https://rubygems.org/gems/oj) gem instead (it builds there via the MSYS2 devkit); `oj_windows` is only needed for native MSVC (`mswin`) builds.
+
+## Requirements
+
+| Component | Version |
+|-----------|---------|
+| Ruby | 3.4.8+ (MSVC build) |
+| OS | Windows 10/11 x64 |
+| Compiler | Visual Studio 2022+ |
+| Architecture | x64-mswin64_140 |
+
+## Installation
+
+```powershell
+gem install oj_windows
+```
+
+Or in your Gemfile:
+
+```ruby
+gem 'oj_windows'
+```
+
+## Quick Start
+
+```ruby
+require 'oj_windows'
+
+# Dump Ruby objects to JSON
+hash = { 'name' => 'oj_windows', 'version' => '3.17.2.1', 'windows' => true }
+json = Oj.dump(hash)
+# => {"name":"oj_windows","version":"3.16.14","windows":true}
+
+# Load JSON back to Ruby objects  
+data = Oj.load(json)
+# => {"name"=>"oj_windows", "version"=>"3.16.14", "windows"=>true}
+
+# Pretty print
+puts Oj.dump(hash, indent: 2)
+```
+
+## Features
+
+- **SIMD-accelerated** C extension compiled with MSVC (SSE2 string scanning on x86_64)
+- **Multiple Modes**: Strict, Compat, Object, Custom, Rails, WAB, Null
+- **JSON Gem Compatibility**: Drop-in replacement via `Oj.mimic_JSON`
+- **Rails Integration**: `:rails` mode and `Oj.optimize_rails` for ActiveSupport/ActiveRecord (see note under Test Results)
+- **Streaming**: SAJ and SC parsers for large documents
+- **Safe parsing**: `Oj::Parser.safe(max_depth:, max_array_size:, max_hash_size:, max_total_elements:)` enforces limits on untrusted input
+- **StringWriter/StreamWriter**: Efficient JSON generation
+
+## Test Results
+
+All tests pass on Windows MSVC Ruby 3.4.8:
+
+| Test Suite | Runs | Assertions | Failures | Errors | Skips |
+|------------|------|------------|----------|--------|-------|
+| test_various.rb | 69 | 8,202 | 0 | 0 | 1 |
+| test_strict.rb | 42 | 71 | 0 | 0 | 0 |
+| test_compat.rb | 55 | 112 | 0 | 0 | 0 |
+| test_object.rb | 74 | 161 | 0 | 0 | 0 |
+| test_fast.rb | 43 | 137 | 0 | 0 | 0 |
+| test_saj.rb | 13 | 18 | 0 | 0 | 0 |
+| test_scp.rb | 23 | 23 | 0 | 0 | 2 |
+| test_gc.rb | 3 | 50 | 0 | 0 | 0 |
+| test_writer.rb | 27 | 28 | 0 | 0 | 1 |
+| test_file.rb | 21 | 52 | 0 | 0 | 1 |
+| test_hash.rb | 3 | 7 | 0 | 0 | 0 |
+| **Total** | **373** | **8,861** | **0** | **0** | **5** |
+
+> **Scope**: This is the core suite run by `test/test_all_no_rails.bat`. Additional mode/parser tests (`test_custom`, `test_null`, `test_wab`, `test_generate`, `test_parser_usual`, `test_integer_range`, `test_long_strings`) also pass. A few files depend on POSIX fixtures or a specific working directory (`test_realworld` needs `test/data/*.json`; `test_parser_saj`'s file test needs a local fixture) and are not part of this table. The Rails ActiveSupport/ActiveRecord suites require `fork` and are not run on Windows.
+>
+> **Skips (5)**: 3 require `fork` (`test_various` ×1, `test_scp` ×2), 1 needs a POSIX subprocess (`test_writer`), and 1 involves pre-1970 dates the Windows time API does not support (`test_file`).
+
+## Performance
+
+`oj_windows` enables SIMD-accelerated string scanning on x86_64 (SSE2 by default —
+see [InstallOptions](pages/InstallOptions.md)). On string-heavy payloads this makes
+parsing roughly **20–25% faster** than the scalar build that earlier versions
+shipped on MSVC.
+
+A note on honest benchmarking: Ruby's bundled `JSON::Ext` is extremely well
+optimized and is competitive with — and on small, simple payloads can exceed —
+`oj_windows` on raw parse/dump throughput. Oj's value is less about winning a
+micro-benchmark and more about capabilities the JSON gem does not offer:
+
+- **Object mode** — full Ruby object serialization/deserialization
+- **Rails / ActiveSupport** integration (`Oj.optimize_rails`)
+- **Streaming** parsers (SAJ, SCP) for large documents
+- **Custom** serialization behavior and circular-reference handling
+
+Benchmark your own representative payloads with the scripts in `test/perf_*.rb`
+rather than relying on synthetic numbers.
+
+## Modes
+
+| Mode | Description |
+|------|-------------|
+| `:strict` | Strict JSON compliance, only native types |
+| `:compat` | Compatible with the JSON gem |
+| `:object` | Full Ruby object serialization |
+| `:custom` | Customizable serialization behavior |
+| `:rails` | Rails and ActiveSupport compatibility |
+| `:wab` | WAB (Web Application Builder) format |
+| `:null` | Return null for unsupported types |
+
+## Configuration
+
+```ruby
+# Set default options
+Oj.default_options = {
+  mode: :compat,
+  symbol_keys: true,
+  indent: 2
+}
+
+# Check current options
+Oj.default_options
+```
+
+## Documentation
+
+- [Options](pages/Options.md) - Parse and dump options
+- [Modes](pages/Modes.md) - Detailed mode documentation
+- [Rails](pages/Rails.md) - Rails integration guide
+- [JsonGem](pages/JsonGem.md) - JSON gem compatibility
+- [Advanced](pages/Advanced.md) - Advanced features
+
+## Building from Source
+
+```powershell
+# Requires a Visual Studio (2019+) MSVC build environment. package_install.bat
+# locates vcvars64.bat automatically via vswhere, so just run:
+.\package_install.bat
+```
+
+> If you prefer to set up the environment yourself, run the `vcvars64.bat` from
+> your Visual Studio install (e.g. `...\Microsoft Visual Studio\2022\Community\VC\Auxiliary\Build\vcvars64.bat`)
+> first, then `bundle exec rake compile`.
+
+## Running Tests
+
+```powershell
+cd test
+.\test_all_no_rails.bat
+```
+
+## License
+
+MIT License - See [LICENSE](LICENSE) for details.
+
+---
+
+*Version 3.17.2.1 — based on [Oj](https://github.com/ohler55/oj) 3.17.2 by Peter Ohler (MIT).*

data/ext/oj_windows/extconf.rb

@@ -52,6 +52,13 @@ if enable_config('trace-log', false)
   dflags['OJ_ENABLE_TRACE_LOG'] = 1
 end
 
+# SIMD string scanning is enabled by default (SSE2/SSE4.2 on x86_64 including
+# MSVC, NEON on ARM). Build with `--disable-simd` to force the portable scalar
+# scanner, e.g. `gem install oj_windows -- --disable-simd`.
+unless enable_config('simd', true)
+  dflags['OJ_DISABLE_SIMD'] = 1
+end
+
 dflags.each do |k, v|
   if v.nil?
     $CPPFLAGS += " -D#{k}"
@@ -70,8 +77,7 @@ end
 
 create_makefile(File.join(extension_name, extension_name))
 
-if is_windows
-  %x{nmake clean}
-else
-  %x{make clean}
-end
+# NOTE: do not run `nmake clean` / `make clean` here. This file runs during
+# `gem install` right before the build step, so cleaning is pointless on a fresh
+# install (there is nothing to clean) and only emits confusing output. Use
+# `rake clean` for local development instead.

data/ext/oj_windows/mem.c

@@ -31,7 +31,21 @@ typedef struct _rep {
 
 #ifdef MEM_DEBUG
 
-static pthread_mutex_t lock      = PTHREAD_MUTEX_INITIALIZER;
+#if IS_WINDOWS
+// Included here (after ruby.h, which already pulls in winsock2/windows on mswin)
+// to avoid the winsock.h vs winsock2.h redefinition clash that occurs if
+// <windows.h> is included ahead of Ruby's headers.
+#include <windows.h>
+// CRITICAL_SECTION has no static initializer, but SRWLOCK does (SRWLOCK_INIT)
+// and is the natural Windows equivalent for this simple debug-only lock.
+static SRWLOCK lock = SRWLOCK_INIT;
+#define MEM_LOCK()   AcquireSRWLockExclusive(&lock)
+#define MEM_UNLOCK() ReleaseSRWLockExclusive(&lock)
+#else
+static pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
+#define MEM_LOCK()   pthread_mutex_lock(&lock)
+#define MEM_UNLOCK() pthread_mutex_unlock(&lock)
+#endif
 static Rec             recs      = NULL;
 static const char      mem_pad[] = "--- This is a memory pad and should not change until being freed. ---";
 
@@ -48,10 +62,10 @@ void *oj_malloc(size_t size, const char *file, int line) {
             r->file = file;
             r->line = line;
             r->ruby = false;
-            pthread_mutex_lock(&lock);
+            MEM_LOCK();
             r->next = recs;
             recs    = r;
-            pthread_mutex_unlock(&lock);
+            MEM_UNLOCK();
         } else {
             free(ptr);
             ptr = NULL;
@@ -66,7 +80,7 @@ void *oj_realloc(void *orig, size_t size, const char *file, int line) {
 
     if (NULL != ptr) {
         strcpy(((char *)ptr) + size, mem_pad);
-        pthread_mutex_lock(&lock);
+        MEM_LOCK();
         for (r = recs; NULL != r; r = r->next) {
             if (orig == r->ptr) {
                 r->ptr  = ptr;
@@ -77,7 +91,7 @@ void *oj_realloc(void *orig, size_t size, const char *file, int line) {
                 break;
             }
         }
-        pthread_mutex_unlock(&lock);
+        MEM_UNLOCK();
         if (NULL == r) {
             printf("Realloc at %s:%d (%p) not allocated.\n", file, line, orig);
         }
@@ -100,10 +114,10 @@ void *oj_calloc(size_t count, size_t size, const char *file, int line) {
             r->file = file;
             r->line = line;
             r->ruby = false;
-            pthread_mutex_lock(&lock);
+            MEM_LOCK();
             r->next = recs;
             recs    = r;
-            pthread_mutex_unlock(&lock);
+            MEM_UNLOCK();
         } else {
             free(ptr);
             ptr = NULL;
@@ -125,10 +139,10 @@ void *oj_r_alloc(size_t size, const char *file, int line) {
             r->file = file;
             r->line = line;
             r->ruby = true;
-            pthread_mutex_lock(&lock);
+            MEM_LOCK();
             r->next = recs;
             recs    = r;
-            pthread_mutex_unlock(&lock);
+            MEM_UNLOCK();
         } else {
             free(ptr);
             ptr = NULL;
@@ -143,7 +157,7 @@ void *oj_r_realloc(void *orig, size_t size, const char *file, int line) {
 
     if (NULL != ptr) {
         strcpy(((char *)ptr) + size, mem_pad);
-        pthread_mutex_lock(&lock);
+        MEM_LOCK();
         for (r = recs; NULL != r; r = r->next) {
             if (orig == r->ptr) {
                 r->ptr  = ptr;
@@ -154,7 +168,7 @@ void *oj_r_realloc(void *orig, size_t size, const char *file, int line) {
                 break;
             }
         }
-        pthread_mutex_unlock(&lock);
+        MEM_UNLOCK();
         if (NULL == r) {
             printf("Realloc at %s:%d (%p) not allocated.\n", file, line, orig);
         }
@@ -167,7 +181,7 @@ void oj_freed(void *ptr, const char *file, int line, bool ruby) {
         Rec r    = NULL;
         Rec prev = NULL;
 
-        pthread_mutex_lock(&lock);
+        MEM_LOCK();
         for (r = recs; NULL != r; r = r->next) {
             if (ptr == r->ptr) {
                 if (NULL == prev) {
@@ -179,7 +193,7 @@ void oj_freed(void *ptr, const char *file, int line, bool ruby) {
             }
             prev = r;
         }
-        pthread_mutex_unlock(&lock);
+        MEM_UNLOCK();
         if (NULL == r) {
             printf("Free at %s:%d (%p) not allocated or already freed.\n", file, line, ptr);
         } else {
@@ -242,10 +256,10 @@ char *oj_mem_strdup(const char *str, const char *file, int line) {
             r->file = file;
             r->line = line;
             r->ruby = false;
-            pthread_mutex_lock(&lock);
+            MEM_LOCK();
             r->next = recs;
             recs    = r;
-            pthread_mutex_unlock(&lock);
+            MEM_UNLOCK();
         } else {
             free(ptr);
             ptr = NULL;
@@ -281,7 +295,7 @@ static Rep update_reps(Rep reps, Rec r) {
 
 static void print_stats() {
     printf("\n--- Memory Usage Report --------------------------------------------------------\n");
-    pthread_mutex_lock(&lock);
+    MEM_LOCK();
 
     if (NULL == recs) {
         printf("No memory leaks\n");
@@ -306,7 +320,7 @@ static void print_stats() {
         }
         printf("%lu bytes leaked\n", leaked);
     }
-    pthread_mutex_unlock(&lock);
+    MEM_UNLOCK();
     printf("--------------------------------------------------------------------------------\n");
 }
 

data/ext/oj_windows/oj.h

@@ -34,6 +34,12 @@ extern "C" {
 #if defined(_MSC_VER)
 #define __attribute__(x)
 #define timegm _mkgmtime
+// MSVC has no native ssize_t (only SSIZE_T from <BaseTsd.h>, pulled in by
+// <windows.h> above). Ruby's mswin headers normally define ssize_t/HAVE_SSIZE_T;
+// provide a fallback only if they did not, so the extension never relies on it.
+#if !defined(HAVE_SSIZE_T) && !defined(ssize_t)
+typedef SSIZE_T ssize_t;
+#endif
 #endif
 #else
 #define IS_WINDOWS 0