win32-nio 0.2.1 → 0.2.2

data/appveyor.yml

@@ -0,0 +1,45 @@
+version: '{build}'
+branches:
+  only:
+  - C
+skip_tags: true
+clone_depth: 10
+environment:
+  matrix:
+  - ruby_version: 200
+    ruby_dir: 2.0.0
+  - ruby_version: 200-x64
+    ruby_dir: 2.0.0
+  - ruby_version: 21
+    ruby_dir: 2.1.0
+  - ruby_version: 21-x64
+    ruby_dir: 2.1.0
+  - ruby_version: 22
+    ruby_dir: 2.2.0
+  - ruby_version: 22-x64
+    ruby_dir: 2.2.0
+install:
+- ps: >-
+    $env:path = "C:\Ruby" + $env:ruby_version + "\bin;" + $env:path
+
+    $tpath = "C:\Ruby" + $env:ruby_version + "\lib\ruby\" + $env:ruby_dir + "\test"
+
+    if ((test-path $tpath) -eq $True){ rm -recurse -force $tpath }
+
+    gem update --system > $null
+
+    if ((gem query -i win32-event) -eq $False){ gem install win32-event --no-document }
+
+    if ((gem query -i test-unit -v ">= 3.0") -eq $False){ gem install test-unit --no-document }
+
+    C:\Ruby21\DevKit\devkitvars.bat
+cache:
+- C:\Ruby200\lib\ruby\gems\2.0.0
+- C:\Ruby200-x64\lib\ruby\gems\2.0.0
+- C:\Ruby21\lib\ruby\gems\2.1.0
+- C:\Ruby21-x64\lib\ruby\gems\2.1.0
+- C:\Ruby22\lib\ruby\gems\2.2.0
+- C:\Ruby22-x64\lib\ruby\gems\2.2.0
+build: off
+test_script:
+- cmd: rake

data/benchmarks/win32_nio_benchmarks.rb

@@ -1,113 +1,113 @@
-########################################################################
-# win32_nio_benchmarks.rb
-#
-# Run this via the 'rake bench' task to compare win32-nio with Ruby's
-# own IO methods. This benchmark will take a bit of time, since it
-# generates some test files on the fly.
-########################################################################
-require 'benchmark'
-require 'win32/nio'
-include Win32
-
-MAX = (ARGV[0] || '10').chomp.to_i # Default to 10 iterations
-PHRASE = "The quick brown fox jumped over the lazy dog's back"
-
-SMALL_FILE  = "small_nio_test.txt"  # 588k
-MEDIUM_FILE = "medium_nio_test.txt" # 6mb
-LARGE_FILE  = "large_nio_test.txt"  # 60mb
-HUGE_FILE   = "huge_nio_test.txt"   # 618mb
-
-unless File.exists?(SMALL_FILE)
-   File.open(SMALL_FILE, 'w'){ |fh|
-      10000.times{ |n| fh.puts PHRASE + ": #{n}" }
-   }
-
-   puts "Small file created"
-end
-
-unless File.exists?(MEDIUM_FILE)
-   File.open(MEDIUM_FILE, 'w'){ |fh|
-      110000.times{ |n| fh.puts PHRASE + ": #{n}" }
-   }
-
-   puts "Medium file created"
-end
-
-unless File.exists?(LARGE_FILE)
-   File.open(LARGE_FILE, 'w'){ |fh|
-      1000000.times{ |n| fh.puts PHRASE + ": #{n}" }
-   }
-
-   puts "Large file created"
-end
-
-unless File.exists?(HUGE_FILE)
-   #File.open(HUGE_FILE, 'w'){ |fh|
-   #   10000000.times{ |n| fh.puts PHRASE + ": #{n}" }
-   #}
-
-   #puts "Huge file created"
-end
-
-Benchmark.bm(20) do |x|
-   x.report('IO.read(small)'){
-      MAX.times{ IO.read(SMALL_FILE) }
-   }
-
-   x.report('NIO.read(small)'){
-      MAX.times{ NIO.read(SMALL_FILE) }
-   }
-
-   x.report('IO.read(medium)'){
-      MAX.times{ IO.read(MEDIUM_FILE) }
-   }
-
-   x.report('NIO.read(medium)'){
-      MAX.times{ NIO.read(MEDIUM_FILE) }
-   }
-
-   x.report('IO.read(large)'){
-      MAX.times{ IO.read(LARGE_FILE) }
-   }
-
-   x.report('NIO.read(large)'){
-      MAX.times{ NIO.read(LARGE_FILE) }
-   }
-
-   #x.report('IO.read(huge)'){
-   #   MAX.times{ IO.read(HUGE_FILE) }
-   #}
-
-   #x.report('NIO.read(huge)'){
-   #   MAX.times{ NIO.read(HUGE_FILE) }
-   #}
-
-   x.report('IO.readlines(small)'){
-      MAX.times{ IO.readlines(SMALL_FILE) }
-   }
-
-   x.report('NIO.readlines(small)'){
-      MAX.times{ NIO.readlines(SMALL_FILE) }
-   }
-   
-   x.report('IO.readlines(medium)'){
-      MAX.times{ IO.readlines(MEDIUM_FILE) }
-   }
-
-   x.report('NIO.readlines(medium)'){
-      MAX.times{ NIO.readlines(MEDIUM_FILE) }
-   }
-   
-   x.report('IO.readlines(large)'){
-      MAX.times{ IO.readlines(LARGE_FILE) }
-   }
-
-   x.report('NIO.readlines(large)'){
-      MAX.times{ NIO.readlines(LARGE_FILE) }
-   }
-end
-
-File.delete(SMALL_FILE) if File.exists?(SMALL_FILE)
-File.delete(MEDIUM_FILE) if File.exists?(MEDIUM_FILE)
-File.delete(LARGE_FILE) if File.exists?(LARGE_FILE)
-File.delete(HUGE_FILE) if File.exists?(HUGE_FILE)
+########################################################################
+# win32_nio_benchmarks.rb
+#
+# Run this via the 'rake bench' task to compare win32-nio with Ruby's
+# own IO methods. This benchmark will take a bit of time, since it
+# generates some test files on the fly.
+########################################################################
+require 'benchmark'
+require 'win32/nio'
+include Win32
+
+MAX = (ARGV[0] || '10').chomp.to_i # Default to 10 iterations
+PHRASE = "The quick brown fox jumped over the lazy dog's back"
+
+SMALL_FILE  = "small_nio_test.txt"  # 588k
+MEDIUM_FILE = "medium_nio_test.txt" # 6mb
+LARGE_FILE  = "large_nio_test.txt"  # 60mb
+HUGE_FILE   = "huge_nio_test.txt"   # 618mb
+
+unless File.exists?(SMALL_FILE)
+   File.open(SMALL_FILE, 'w'){ |fh|
+      10000.times{ |n| fh.puts PHRASE + ": #{n}" }
+   }
+
+   puts "Small file created"
+end
+
+unless File.exists?(MEDIUM_FILE)
+   File.open(MEDIUM_FILE, 'w'){ |fh|
+      110000.times{ |n| fh.puts PHRASE + ": #{n}" }
+   }
+
+   puts "Medium file created"
+end
+
+unless File.exists?(LARGE_FILE)
+   File.open(LARGE_FILE, 'w'){ |fh|
+      1000000.times{ |n| fh.puts PHRASE + ": #{n}" }
+   }
+
+   puts "Large file created"
+end
+
+unless File.exists?(HUGE_FILE)
+   #File.open(HUGE_FILE, 'w'){ |fh|
+   #   10000000.times{ |n| fh.puts PHRASE + ": #{n}" }
+   #}
+
+   #puts "Huge file created"
+end
+
+Benchmark.bm(20) do |x|
+   x.report('IO.read(small)'){
+      MAX.times{ IO.read(SMALL_FILE) }
+   }
+
+   x.report('NIO.read(small)'){
+      MAX.times{ NIO.read(SMALL_FILE) }
+   }
+
+   x.report('IO.read(medium)'){
+      MAX.times{ IO.read(MEDIUM_FILE) }
+   }
+
+   x.report('NIO.read(medium)'){
+      MAX.times{ NIO.read(MEDIUM_FILE) }
+   }
+
+   x.report('IO.read(large)'){
+      MAX.times{ IO.read(LARGE_FILE) }
+   }
+
+   x.report('NIO.read(large)'){
+      MAX.times{ NIO.read(LARGE_FILE) }
+   }
+
+   #x.report('IO.read(huge)'){
+   #   MAX.times{ IO.read(HUGE_FILE) }
+   #}
+
+   #x.report('NIO.read(huge)'){
+   #   MAX.times{ NIO.read(HUGE_FILE) }
+   #}
+
+   x.report('IO.readlines(small)'){
+      MAX.times{ IO.readlines(SMALL_FILE) }
+   }
+
+   x.report('NIO.readlines(small)'){
+      MAX.times{ NIO.readlines(SMALL_FILE) }
+   }
+   
+   x.report('IO.readlines(medium)'){
+      MAX.times{ IO.readlines(MEDIUM_FILE) }
+   }
+
+   x.report('NIO.readlines(medium)'){
+      MAX.times{ NIO.readlines(MEDIUM_FILE) }
+   }
+   
+   x.report('IO.readlines(large)'){
+      MAX.times{ IO.readlines(LARGE_FILE) }
+   }
+
+   x.report('NIO.readlines(large)'){
+      MAX.times{ NIO.readlines(LARGE_FILE) }
+   }
+end
+
+File.delete(SMALL_FILE) if File.exists?(SMALL_FILE)
+File.delete(MEDIUM_FILE) if File.exists?(MEDIUM_FILE)
+File.delete(LARGE_FILE) if File.exists?(LARGE_FILE)
+File.delete(HUGE_FILE) if File.exists?(HUGE_FILE)

data/certs/djberg96_pub.pem

@@ -0,0 +1,21 @@
+-----BEGIN CERTIFICATE-----
+MIIDcDCCAligAwIBAgIBATANBgkqhkiG9w0BAQUFADA/MREwDwYDVQQDDAhkamJl
+cmc5NjEVMBMGCgmSJomT8ixkARkWBWdtYWlsMRMwEQYKCZImiZPyLGQBGRYDY29t
+MB4XDTE1MDkwMjIwNDkxOFoXDTE2MDkwMTIwNDkxOFowPzERMA8GA1UEAwwIZGpi
+ZXJnOTYxFTATBgoJkiaJk/IsZAEZFgVnbWFpbDETMBEGCgmSJomT8ixkARkWA2Nv
+bTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAMyTkvXqRp6hLs9eoJOS
+Hmi8kRYbq9Vkf15/hMxJpotYMgJVHHWrmDcC5Dye2PbnXjTkKf266Zw0PtT9h+lI
+S3ts9HO+vaCFSMwFFZmnWJSpQ3CNw2RcHxjWkk9yF7imEM8Kz9ojhiDXzBetdV6M
+gr0lV/alUr7TNVBDngbXEfTWscyXh1qd7xZ4EcOdsDktCe5G45N/o3662tPQvJsi
+FOF0CM/KuBsa/HL1/eoEmF4B3EKIRfTHrQ3hu20Kv3RJ88QM4ec2+0dd97uX693O
+zv6981fyEg+aXLkxrkViM/tz2qR2ZE0jPhHTREPYeMEgptRkTmWSKAuLVWrJEfgl
+DtkCAwEAAaN3MHUwCQYDVR0TBAIwADALBgNVHQ8EBAMCBLAwHQYDVR0OBBYEFEwe
+nn6bfJADmuIDiMSOzedOrL+xMB0GA1UdEQQWMBSBEmRqYmVyZzk2QGdtYWlsLmNv
+bTAdBgNVHRIEFjAUgRJkamJlcmc5NkBnbWFpbC5jb20wDQYJKoZIhvcNAQEFBQAD
+ggEBAHmNOCWoDVD75zHFueY0viwGDVP1BNGFC+yXcb7u2GlK+nEMCORqzURbYPf7
+tL+/hzmePIRz7i30UM//64GI1NLv9jl7nIwjhPpXpf7/lu2I9hOTsvwSumb5UiKC
+/sqBxI3sfj9pr79Wpv4MuikX1XPik7Ncb7NPsJPw06Lvyc3Hkg5X2XpPtLtS+Gr2
+wKJnmzb5rIPS1cmsqv0M9LPWflzfwoZ/SpnmhagP+g05p8bRNKjZSA2iImM/GyYZ
+EJYzxdPOrx2n6NYR3Hk+vHP0U7UBSveI6+qx+ndQYaeyCn+GRX2PKS9h66YF/Q1V
+tGSHgAmcLlkdGgan182qsE/4kKM=
+-----END CERTIFICATE-----

data/ext/extconf.rb

@@ -1,2 +1,2 @@
-require 'mkmf'
-create_makefile('win32/nio', 'win32')
+require 'mkmf'
+create_makefile('win32/nio', 'win32')

data/ext/win32/nio.c

@@ -1,355 +1,355 @@
-#include <ruby.h>
-#include <ruby/encoding.h>
-#include <windows.h>
-#include <math.h>
-
-// Callback used when a block is provided to read method. It simply calls the block.
-void CALLBACK read_complete(DWORD dwErrorCode, DWORD dwBytes, LPOVERLAPPED olap){
-  VALUE p = rb_block_proc();
-  rb_funcall(p, rb_intern("call"), 0);
-}
-
-// Helper function to raise system errors the way I would like
-void rb_raise_syserr(const char* msg, int errnum){
-  VALUE v_sys = rb_funcall(rb_eSystemCallError, rb_intern("new"), 2, rb_str_new2(msg), INT2FIX(errnum));
-  rb_funcall(rb_mKernel, rb_intern("raise"), 1, v_sys);
-}
-
-/*
-* NIO.read(file, length=nil, offset=0, options=nil){ # optional block }
-*
-* This method is similar to Ruby's IO.read method except that it uses
-* native function calls. It also optionally accepts a Win32::Event object,
-* signalling it upon completion. If provided it calls a block upon completion
-* of the read.
-*
-* Examples:
-*
-* # Read everything
-* Win32::NIO.read(file)
-*
-* # Read the first 100 bytes
-* Win32::NIO.read(file, 100)
-*
-* # Read 50 bytes starting at offset 10
-* Win32::NIO.read(file, 50, 10)
-*
-* Note that the +options+ that may be passed to this method are limited
-* to :encoding, :mode and :event because we're no longer using the open
-* function internally. In the case of :mode the only thing that is checked
-* for is the presence of the 'b' (binary) mode.
-*
-* The :event option, if present, must be a Win32::Event object.
-*/
-static VALUE rb_nio_read(int argc, VALUE* argv, VALUE self){
-  OVERLAPPED olap;
-  HANDLE h;
-  DWORD bytes_read;
-  LARGE_INTEGER lsize;
-  BOOL b;
-  VALUE v_file, v_length, v_offset, v_options;
-  VALUE v_event, v_mode, v_encoding, v_result;
-  size_t length;
-  int flags, error, size;
-  wchar_t* file = NULL;
-  char* buffer = NULL;
-
-  memset(&olap, 0, sizeof(olap));
-
-  // Paranoid initialization
-  v_length = Qnil;
-  v_offset = Qnil;
-  v_options = Qnil;
-
-  rb_scan_args(argc, argv, "13", &v_file, &v_length, &v_offset, &v_options);
-
-  // Allow path-y objects.
-  if (rb_respond_to(v_file, rb_intern("to_path")))
-    v_file = rb_funcall(v_file, rb_intern("to_path"), 0, NULL);
-
-  SafeStringValue(v_file);
-
-  // If a length is provided it cannot be negative.
-  if (!NIL_P(v_length)){
-    length = NUM2SIZET(v_length);
-    if ((int)length < 0)
-      rb_raise(rb_eArgError, "negative length %i given", (int)length);
-  }
-  else{
-    length = 0; // Mostly to make gcc stfu. We'll set this later.
-  }
-
-  // Unlike MRI, don't wait for an internal C function to fail on an invalid argument.
-  if (!NIL_P(v_offset)){
-    olap.Offset = NUM2ULONG(v_offset);
-    if ((int)olap.Offset < 0)
-      rb_raise(rb_eArgError, "negative offset %i given", (int)olap.Offset);
-  }
-
-  // Gotta do this for wide character function support.
-  size = MultiByteToWideChar(CP_UTF8, 0, RSTRING_PTR(v_file), -1, NULL, 0);
-  file = (wchar_t*)ruby_xmalloc(MAX_PATH * sizeof(wchar_t));
-
-  if (!MultiByteToWideChar(CP_UTF8, 0, RSTRING_PTR(v_file), -1, file, size)){
-    ruby_xfree(file);
-    rb_raise_syserr("MultibyteToWideChar", GetLastError());
-  }
-
-  flags = FILE_FLAG_SEQUENTIAL_SCAN;
-
-  // Possible options are :event, :mode and :encoding
-  if (!NIL_P(v_options)){
-    Check_Type(v_options, T_HASH);
-
-    v_event = rb_hash_aref(v_options, ID2SYM(rb_intern("event")));
-    v_encoding = rb_hash_aref(v_options, ID2SYM(rb_intern("encoding")));
-    v_mode = rb_hash_aref(v_options, ID2SYM(rb_intern("mode")));
-
-    if (!NIL_P(v_event)){
-      flags |= FILE_FLAG_OVERLAPPED;
-      olap.hEvent = (HANDLE)(uintptr_t)NUM2OFFT(rb_funcall(v_event, rb_intern("handle"), 0, 0));
-    }
-  }
-  else{
-    v_event = Qnil;
-    v_encoding = Qnil;
-    v_mode = Qnil;
-  }
-
-  h = CreateFileW(
-    file,
-    GENERIC_READ,
-    FILE_SHARE_READ,
-    NULL,
-    OPEN_EXISTING,
-    flags,
-    NULL
-  );
-
-  if (h == INVALID_HANDLE_VALUE)
-    rb_raise_syserr("CreateFile", GetLastError());
-
-  // Get the file size. We may use this later to limit read length.
-  if (!GetFileSizeEx(h, &lsize)){
-    error = GetLastError();
-    CloseHandle(h);
-    rb_raise_syserr("GetFileSizeEx", error);
-  }
-
-  // If no length is specified, read the entire file
-  if (NIL_P(v_length))
-    length = (size_t)lsize.QuadPart;
-
-  // Don't read past the end of the file
-  if (olap.Offset + length > (size_t)lsize.QuadPart)
-    length = (size_t)lsize.QuadPart - olap.Offset;
-
-  buffer = (char*)ruby_xmalloc(length * sizeof(char));
-
-  // If a block is given then treat it as a callback
-  if (rb_block_given_p()){
-    flags |= FILE_FLAG_OVERLAPPED;
-    b = ReadFileEx(h, buffer, length, &olap, read_complete);
-  }
-  else{
-    b = ReadFile(h, buffer, length, &bytes_read, &olap);
-  }
-
-  error = GetLastError();
-
-  // Put in alertable wait state if overlapped IO
-  if (flags & FILE_FLAG_OVERLAPPED)
-    SleepEx(1, TRUE);
-
-  if (!b){
-    if(error == ERROR_IO_PENDING){
-      DWORD bytes;
-      if (!GetOverlappedResult(h, &olap, &bytes, TRUE)){
-        ruby_xfree(buffer);
-        CloseHandle(h);
-        rb_raise_syserr("GetOverlappedResult", error);
-      }
-    }
-    else{
-      ruby_xfree(buffer);
-      CloseHandle(h);
-      rb_raise_syserr("ReadFile", error);
-    }
-  }
-
-  CloseHandle(h);
-
-  v_result = rb_str_new(buffer, length);
-  ruby_xfree(buffer);
-
-  // Convert CRLF to LF if text mode
-  if (!NIL_P(v_mode) && strstr(RSTRING_PTR(v_mode), "t"))
-    rb_funcall(v_result, rb_intern("gsub!"), 2, rb_str_new2("\r\n"), rb_gv_get("$/"));
-
-  if (!NIL_P(v_encoding))
-    rb_funcall(v_result, rb_intern("encode!"), 1, v_encoding);
-
-  return v_result;
-}
-
-/*
- * NIO.readlines(file, sep="\r\n", event=nil)
- *
- * Reads the entire file specified by portname as individual lines, and
- * returns those lines in an array. Lines are separated by +sep+. The +event+
- * argument must be a Win32::Event if present, and it is signalled upon
- * completion.
- *
- * Examples:
- *
- *   # Standard call
- *   Win32::NIO.readlines('file.txt') # => ['line 1', 'line 2', 'line 3', 'line 4']
- *
- *   # Paragraph mode
- *   Win32::NIO.readlines('file.txt', '') # => ['line 1\r\nline 2', 'line 3\r\nline 4']
- *
- *   # With event
- *   event = Win32::Event.new
- *   Win32::NIO.readlines('file.txt', nil, event)
- *   p event.signaled? # => true
- *
- * Superficially this method acts the same as the Ruby IO.readlines call, except that
- * it does not transform line endings and accepts an optional event object. However,
- * internally this method is using a scattered read to accomplish its goal. In practice
- * this is only relevant in specific situations. Using it outside of those situations
- * is unlikely to provide any practical benefit, and may even result in slower performance.
- *
- * See information on vectored IO for more details.
- */
-static VALUE rb_nio_readlines(int argc, VALUE* argv, VALUE self){
-  HANDLE h;
-  SYSTEM_INFO info;
-  LARGE_INTEGER file_size;
-  size_t length, page_size;
-  double size;
-  void* base_address;
-  int error, page_num;
-  wchar_t* file;
-  VALUE v_file, v_sep, v_event, v_result;
-
-  rb_scan_args(argc, argv, "12", &v_file, &v_sep, &v_event);
-
-  SafeStringValue(v_file);
-
-  if (NIL_P(v_sep))
-    v_sep = rb_str_new2("\r\n");
-  else
-    SafeStringValue(v_sep);
-
-  v_result = Qnil;
-
-  length = MultiByteToWideChar(CP_UTF8, 0, RSTRING_PTR(v_file), -1, NULL, 0);
-  file = (wchar_t*)ruby_xmalloc(MAX_PATH * sizeof(wchar_t));
-
-  if (!MultiByteToWideChar(CP_UTF8, 0, RSTRING_PTR(v_file), -1, file, length)){
-    ruby_xfree(file);
-    rb_raise_syserr("MultibyteToWideChar", GetLastError());
-  }
-
-  h = CreateFileW(
-    file,
-    GENERIC_READ,
-    FILE_SHARE_READ,
-    NULL,
-    OPEN_EXISTING,
-    FILE_FLAG_OVERLAPPED | FILE_FLAG_NO_BUFFERING,
-    NULL
-  );
-
-  if (h == INVALID_HANDLE_VALUE)
-    rb_raise_syserr("CreateFile", GetLastError());
-
-  if (!GetFileSizeEx(h, &file_size)){
-    error = GetLastError();
-    CloseHandle(h);
-    rb_raise_syserr("GetFileSizeEx", error);
-  }
-
-  length = (size_t)file_size.QuadPart;
-
-  GetSystemInfo(&info);
-  page_size = info.dwPageSize;
-
-  page_num = (int)ceil((double)length / page_size);
-
-  size = page_num * page_size;
-
-  base_address = VirtualAlloc(NULL, (size_t)size, MEM_COMMIT, PAGE_READWRITE);
-
-  if (!base_address){
-    error = GetLastError();
-    CloseHandle(h);
-    rb_raise_syserr("VirtualAlloc", error);
-  }
-  else{
-    int i;
-    OVERLAPPED olap;
-    BOOL rv;
-    FILE_SEGMENT_ELEMENT* fse;
-
-    olap.Offset = 0;
-    olap.OffsetHigh = 0;
-
-    if (NIL_P(v_event))
-      olap.hEvent = NULL;
-    else
-      olap.hEvent = (HANDLE)(uintptr_t)NUM2OFFT(rb_funcall(v_event, rb_intern("handle"), 0, 0));
-
-    fse = (FILE_SEGMENT_ELEMENT*)malloc(sizeof(FILE_SEGMENT_ELEMENT) * (page_num + 1));
-    memset(fse, 0, sizeof(FILE_SEGMENT_ELEMENT) * (page_num + 1));
-    v_result = Qnil;
-
-    for (i = 0; i < page_num; i++)
-      fse[i].Alignment = (ULONGLONG)(uintptr_t)base_address + (page_size * i);
-
-    rv = ReadFileScatter(h, fse, (DWORD)size, NULL, &olap);
-
-    if (!rv){
-      error = GetLastError();
-
-      if (error == ERROR_IO_PENDING){
-        while (!HasOverlappedIoCompleted(&olap))
-          SleepEx(1, TRUE);
-      }
-      else{
-        VirtualFree(base_address, 0, MEM_RELEASE);
-        CloseHandle(h);
-        rb_raise_syserr("ReadFileScatter", error);
-      }
-    }
-
-    // Explicitly handle paragraph mode
-    if (rb_equal(v_sep, rb_str_new2(""))){
-      VALUE v_args[1];
-      v_args[0] = rb_str_new2("(\r\n){2,}");
-      v_sep = rb_class_new_instance(1, v_args, rb_cRegexp);
-      v_result = rb_funcall(rb_str_new2(fse[0].Buffer), rb_intern("split"), 1, v_sep);
-      rb_funcall(v_result, rb_intern("delete"), 1, rb_str_new2("\r\n"));
-    }
-    else{
-      v_result = rb_funcall(rb_str_new2(fse[0].Buffer), rb_intern("split"), 1, v_sep);
-    }
-
-    VirtualFree(base_address, 0, MEM_RELEASE);
-  }
-
-  CloseHandle(h);
-
-  return v_result;
-}
-
-void Init_nio(){
-  VALUE mWin32 = rb_define_module("Win32");
-  VALUE cNio = rb_define_class_under(mWin32, "NIO", rb_cObject);
-
-  rb_define_singleton_method(cNio, "read", rb_nio_read, -1);
-  rb_define_singleton_method(cNio, "readlines", rb_nio_readlines, -1);
-
-  /* 0.2.1: The version of the win32-nio library */
-  rb_define_const(cNio, "VERSION", rb_str_new2("0.2.1"));
-}
+#include <ruby.h>
+#include <ruby/encoding.h>
+#include <windows.h>
+#include <math.h>
+
+// Callback used when a block is provided to read method. It simply calls the block.
+void CALLBACK read_complete(DWORD dwErrorCode, DWORD dwBytes, LPOVERLAPPED olap){
+  VALUE p = rb_block_proc();
+  rb_funcall(p, rb_intern("call"), 0);
+}
+
+// Helper function to raise system errors the way I would like
+void rb_raise_syserr(const char* msg, int errnum){
+  VALUE v_sys = rb_funcall(rb_eSystemCallError, rb_intern("new"), 2, rb_str_new2(msg), INT2FIX(errnum));
+  rb_funcall(rb_mKernel, rb_intern("raise"), 1, v_sys);
+}
+
+/*
+* NIO.read(file, length=nil, offset=0, options=nil){ # optional block }
+*
+* This method is similar to Ruby's IO.read method except that it uses
+* native function calls. It also optionally accepts a Win32::Event object,
+* signalling it upon completion. If provided it calls a block upon completion
+* of the read.
+*
+* Examples:
+*
+* # Read everything
+* Win32::NIO.read(file)
+*
+* # Read the first 100 bytes
+* Win32::NIO.read(file, 100)
+*
+* # Read 50 bytes starting at offset 10
+* Win32::NIO.read(file, 50, 10)
+*
+* Note that the +options+ that may be passed to this method are limited
+* to :encoding, :mode and :event because we're no longer using the open
+* function internally. In the case of :mode the only thing that is checked
+* for is the presence of the 'b' (binary) mode.
+*
+* The :event option, if present, must be a Win32::Event object.
+*/
+static VALUE rb_nio_read(int argc, VALUE* argv, VALUE self){
+  OVERLAPPED olap;
+  HANDLE h;
+  DWORD bytes_read;
+  LARGE_INTEGER lsize;
+  BOOL b;
+  VALUE v_file, v_length, v_offset, v_options;
+  VALUE v_event, v_mode, v_encoding, v_result;
+  size_t length;
+  int flags, error, size;
+  wchar_t* file = NULL;
+  char* buffer = NULL;
+
+  memset(&olap, 0, sizeof(olap));
+
+  // Paranoid initialization
+  v_length = Qnil;
+  v_offset = Qnil;
+  v_options = Qnil;
+
+  rb_scan_args(argc, argv, "13", &v_file, &v_length, &v_offset, &v_options);
+
+  // Allow path-y objects.
+  if (rb_respond_to(v_file, rb_intern("to_path")))
+    v_file = rb_funcall(v_file, rb_intern("to_path"), 0, NULL);
+
+  SafeStringValue(v_file);
+
+  // If a length is provided it cannot be negative.
+  if (!NIL_P(v_length)){
+    length = NUM2SIZET(v_length);
+    if ((int)length < 0)
+      rb_raise(rb_eArgError, "negative length %i given", (int)length);
+  }
+  else{
+    length = 0; // Mostly to make gcc stfu. We'll set this later.
+  }
+
+  // Unlike MRI, don't wait for an internal C function to fail on an invalid argument.
+  if (!NIL_P(v_offset)){
+    olap.Offset = NUM2ULONG(v_offset);
+    if ((int)olap.Offset < 0)
+      rb_raise(rb_eArgError, "negative offset %i given", (int)olap.Offset);
+  }
+
+  // Gotta do this for wide character function support.
+  size = MultiByteToWideChar(CP_UTF8, 0, RSTRING_PTR(v_file), -1, NULL, 0);
+  file = (wchar_t*)ruby_xmalloc(MAX_PATH * sizeof(wchar_t));
+
+  if (!MultiByteToWideChar(CP_UTF8, 0, RSTRING_PTR(v_file), -1, file, size)){
+    ruby_xfree(file);
+    rb_raise_syserr("MultibyteToWideChar", GetLastError());
+  }
+
+  flags = FILE_FLAG_SEQUENTIAL_SCAN;
+
+  // Possible options are :event, :mode and :encoding
+  if (!NIL_P(v_options)){
+    Check_Type(v_options, T_HASH);
+
+    v_event = rb_hash_aref(v_options, ID2SYM(rb_intern("event")));
+    v_encoding = rb_hash_aref(v_options, ID2SYM(rb_intern("encoding")));
+    v_mode = rb_hash_aref(v_options, ID2SYM(rb_intern("mode")));
+
+    if (!NIL_P(v_event)){
+      flags |= FILE_FLAG_OVERLAPPED;
+      olap.hEvent = (HANDLE)(uintptr_t)NUM2OFFT(rb_funcall(v_event, rb_intern("handle"), 0, 0));
+    }
+  }
+  else{
+    v_event = Qnil;
+    v_encoding = Qnil;
+    v_mode = Qnil;
+  }
+
+  h = CreateFileW(
+    file,
+    GENERIC_READ,
+    FILE_SHARE_READ,
+    NULL,
+    OPEN_EXISTING,
+    flags,
+    NULL
+  );
+
+  if (h == INVALID_HANDLE_VALUE)
+    rb_raise_syserr("CreateFile", GetLastError());
+
+  // Get the file size. We may use this later to limit read length.
+  if (!GetFileSizeEx(h, &lsize)){
+    error = GetLastError();
+    CloseHandle(h);
+    rb_raise_syserr("GetFileSizeEx", error);
+  }
+
+  // If no length is specified, read the entire file
+  if (NIL_P(v_length))
+    length = (size_t)lsize.QuadPart;
+
+  // Don't read past the end of the file
+  if (olap.Offset + length > (size_t)lsize.QuadPart)
+    length = (size_t)lsize.QuadPart - olap.Offset;
+
+  buffer = (char*)ruby_xmalloc(length * sizeof(char));
+
+  // If a block is given then treat it as a callback
+  if (rb_block_given_p()){
+    flags |= FILE_FLAG_OVERLAPPED;
+    b = ReadFileEx(h, buffer, length, &olap, read_complete);
+  }
+  else{
+    b = ReadFile(h, buffer, length, &bytes_read, &olap);
+  }
+
+  error = GetLastError();
+
+  // Put in alertable wait state if overlapped IO
+  if (flags & FILE_FLAG_OVERLAPPED)
+    SleepEx(1, TRUE);
+
+  if (!b){
+    if(error == ERROR_IO_PENDING){
+      DWORD bytes;
+      if (!GetOverlappedResult(h, &olap, &bytes, TRUE)){
+        ruby_xfree(buffer);
+        CloseHandle(h);
+        rb_raise_syserr("GetOverlappedResult", error);
+      }
+    }
+    else{
+      ruby_xfree(buffer);
+      CloseHandle(h);
+      rb_raise_syserr("ReadFile", error);
+    }
+  }
+
+  CloseHandle(h);
+
+  v_result = rb_str_new(buffer, length);
+  ruby_xfree(buffer);
+
+  // Convert CRLF to LF if text mode
+  if (!NIL_P(v_mode) && strstr(RSTRING_PTR(v_mode), "t"))
+    rb_funcall(v_result, rb_intern("gsub!"), 2, rb_str_new2("\r\n"), rb_gv_get("$/"));
+
+  if (!NIL_P(v_encoding))
+    rb_funcall(v_result, rb_intern("encode!"), 1, v_encoding);
+
+  return v_result;
+}
+
+/*
+ * NIO.readlines(file, sep="\r\n", event=nil)
+ *
+ * Reads the entire file specified by portname as individual lines, and
+ * returns those lines in an array. Lines are separated by +sep+. The +event+
+ * argument must be a Win32::Event if present, and it is signalled upon
+ * completion.
+ *
+ * Examples:
+ *
+ *   # Standard call
+ *   Win32::NIO.readlines('file.txt') # => ['line 1', 'line 2', 'line 3', 'line 4']
+ *
+ *   # Paragraph mode
+ *   Win32::NIO.readlines('file.txt', '') # => ['line 1\r\nline 2', 'line 3\r\nline 4']
+ *
+ *   # With event
+ *   event = Win32::Event.new
+ *   Win32::NIO.readlines('file.txt', nil, event)
+ *   p event.signaled? # => true
+ *
+ * Superficially this method acts the same as the Ruby IO.readlines call, except that
+ * it does not transform line endings and accepts an optional event object. However,
+ * internally this method is using a scattered read to accomplish its goal. In practice
+ * this is only relevant in specific situations. Using it outside of those situations
+ * is unlikely to provide any practical benefit, and may even result in slower performance.
+ *
+ * See information on vectored IO for more details.
+ */
+static VALUE rb_nio_readlines(int argc, VALUE* argv, VALUE self){
+  HANDLE h;
+  SYSTEM_INFO info;
+  LARGE_INTEGER file_size;
+  size_t length, page_size;
+  double size;
+  void* base_address;
+  int error, page_num;
+  wchar_t* file;
+  VALUE v_file, v_sep, v_event, v_result;
+
+  rb_scan_args(argc, argv, "12", &v_file, &v_sep, &v_event);
+
+  SafeStringValue(v_file);
+
+  if (NIL_P(v_sep))
+    v_sep = rb_str_new2("\r\n");
+  else
+    SafeStringValue(v_sep);
+
+  v_result = Qnil;
+
+  length = MultiByteToWideChar(CP_UTF8, 0, RSTRING_PTR(v_file), -1, NULL, 0);
+  file = (wchar_t*)ruby_xmalloc(MAX_PATH * sizeof(wchar_t));
+
+  if (!MultiByteToWideChar(CP_UTF8, 0, RSTRING_PTR(v_file), -1, file, length)){
+    ruby_xfree(file);
+    rb_raise_syserr("MultibyteToWideChar", GetLastError());
+  }
+
+  h = CreateFileW(
+    file,
+    GENERIC_READ,
+    FILE_SHARE_READ,
+    NULL,
+    OPEN_EXISTING,
+    FILE_FLAG_OVERLAPPED | FILE_FLAG_NO_BUFFERING,
+    NULL
+  );
+
+  if (h == INVALID_HANDLE_VALUE)
+    rb_raise_syserr("CreateFile", GetLastError());
+
+  if (!GetFileSizeEx(h, &file_size)){
+    error = GetLastError();
+    CloseHandle(h);
+    rb_raise_syserr("GetFileSizeEx", error);
+  }
+
+  length = (size_t)file_size.QuadPart;
+
+  GetSystemInfo(&info);
+  page_size = info.dwPageSize;
+
+  page_num = (int)ceil((double)length / page_size);
+
+  size = page_num * page_size;
+
+  base_address = VirtualAlloc(NULL, (size_t)size, MEM_COMMIT, PAGE_READWRITE);
+
+  if (!base_address){
+    error = GetLastError();
+    CloseHandle(h);
+    rb_raise_syserr("VirtualAlloc", error);
+  }
+  else{
+    int i;
+    OVERLAPPED olap;
+    BOOL rv;
+    FILE_SEGMENT_ELEMENT* fse;
+
+    olap.Offset = 0;
+    olap.OffsetHigh = 0;
+
+    if (NIL_P(v_event))
+      olap.hEvent = NULL;
+    else
+      olap.hEvent = (HANDLE)(uintptr_t)NUM2OFFT(rb_funcall(v_event, rb_intern("handle"), 0, 0));
+
+    fse = (FILE_SEGMENT_ELEMENT*)malloc(sizeof(FILE_SEGMENT_ELEMENT) * (page_num + 1));
+    memset(fse, 0, sizeof(FILE_SEGMENT_ELEMENT) * (page_num + 1));
+    v_result = Qnil;
+
+    for (i = 0; i < page_num; i++)
+      fse[i].Alignment = (ULONGLONG)(uintptr_t)base_address + (page_size * i);
+
+    rv = ReadFileScatter(h, fse, (DWORD)size, NULL, &olap);
+
+    if (!rv){
+      error = GetLastError();
+
+      if (error == ERROR_IO_PENDING){
+        while (!HasOverlappedIoCompleted(&olap))
+          SleepEx(1, TRUE);
+      }
+      else{
+        VirtualFree(base_address, 0, MEM_RELEASE);
+        CloseHandle(h);
+        rb_raise_syserr("ReadFileScatter", error);
+      }
+    }
+
+    // Explicitly handle paragraph mode
+    if (rb_equal(v_sep, rb_str_new2(""))){
+      VALUE v_args[1];
+      v_args[0] = rb_str_new2("(\r\n){2,}");
+      v_sep = rb_class_new_instance(1, v_args, rb_cRegexp);
+      v_result = rb_funcall(rb_str_new2(fse[0].Buffer), rb_intern("split"), 1, v_sep);
+      rb_funcall(v_result, rb_intern("delete"), 1, rb_str_new2("\r\n"));
+    }
+    else{
+      v_result = rb_funcall(rb_str_new2(fse[0].Buffer), rb_intern("split"), 1, v_sep);
+    }
+
+    VirtualFree(base_address, 0, MEM_RELEASE);
+  }
+
+  CloseHandle(h);
+
+  return v_result;
+}
+
+void Init_nio(){
+  VALUE mWin32 = rb_define_module("Win32");
+  VALUE cNio = rb_define_class_under(mWin32, "NIO", rb_cObject);
+
+  rb_define_singleton_method(cNio, "read", rb_nio_read, -1);
+  rb_define_singleton_method(cNio, "readlines", rb_nio_readlines, -1);
+
+  /* 0.2.2: The version of the win32-nio library */
+  rb_define_const(cNio, "VERSION", rb_str_new2("0.2.2"));
+}