ascii85_native 1.0.1 → 1.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5fbe80d98b9dc9e8d4a04542b578609ce16839be238ad35dd238a001dc02aaa8
-  data.tar.gz: 817069f8f96a4b699f0e8f31bc66ece1f79b190678334dcad478aac0fa910590
+  metadata.gz: e9c131b0e45806651154e7787963fcf0b66caf3c0d178262fc23fc148bd8f5f8
+  data.tar.gz: 824b411d00c8ef1f02d8cda1073f7f12c705599cd2280a60669f8cd268915cf7
 SHA512:
-  metadata.gz: 4b6161b062e5a9641c394d31331a79f6fa4bf96d6fc9e65460f3025c71a0eb09fa5b43faf06f7e973920a0454e864672b2ce395a4afd621899ee95752627ebae
-  data.tar.gz: db9217c98eca4134c50c2d9a01f509dbbc089610165bc062ccbe54d347488b54a9269831d7f3fa8761bfb4e6662fa0dd98be93bfb16cb54e2fc98b39659d613c
+  metadata.gz: b659d5d91700f63b9a04df578b8748047cca28a89a5d0105e781c8e0adb8d3f7838c139f394226dbd27612f97a8f2e2986851bcc639e7d2628f6d1883fa508f3
+  data.tar.gz: e299f89e5df890f1294b6fc8d461a265a155f4285767f87e8cc51459003efc2543e73caf5a6260870df42f6e6322ce3da8ee47024fd4eed6a08eb97760d19070

data/ext/ascii85_native/ascii85_native.c

@@ -2,27 +2,31 @@
 
 #include "stdlib.h"
 #include "ascii85_native.h"
+#include "stdio.h"
+#include "string.h"
 
 int a85_encoded_size(int input_length, bool append_null) {
     return (input_length * 5 + 3) / 4 + !!append_null;
 }
 
 void a85_encode(const u8* input, int input_length, char* output, bool append_null) {
+
     // Go to end of input and output buffers
     input += input_length;
     output += a85_encoded_size(input_length,append_null);
+
     // Append null if requested
-    if (append_null) {
-        *(--output) = 0;
-    }
+    if (append_null) { *(--output) = 0; }
+
     // If number of bytes is not divisible by 4, act as if null bytes were added to end of buffer
     int rem = input_length & 3;
     if (rem) {
         u32 val = 0;
-        for (int i = 4 - rem; i < 4; i++) {
+
+		int i;
+        for (i = 4 - rem; i < 4; i++) {
             val |= *(--input) << (8 * i);
         }
-        int i;
         for (i = 0; i < 4 - rem; i++) {
             val /= 85;
         }
@@ -30,14 +34,17 @@ void a85_encode(const u8* input, int input_length, char* output, bool append_nul
             *(--output) = val % 85 + 33;
             val /= 85;
         }
+
         input_length &= ~3;
     }
+
     while (input_length) {
         // Process chunks of 4 bytes as 32-bit values
         u32 val = *(--input);
         val |= *(--input) << 8;
         val |= *(--input) << 16;
         val |= *(--input) << 24;
+
         // Convert to base 85
         *(--output) = val % 85 + 33;
         val /= 85;
@@ -56,36 +63,16 @@ int a85_decoded_size(int input_length) {
     return ((input_length * 4) / 5);
 }
 
-void a85_filter_before_decode(const char* input, int input_length, char* output) {
-	int input_remaining = input_length;
-	while (input_remaining) {
-        if ( !(*input == 0 || (*input >= 10 && *input <= 13)) ) {
-			*output = *input;
-			output++;
-		}
-		input++;
-		input_remaining--;
-	}
-	//*output = '\0';
-}
-
 void a85_decode(const char* input, int input_length, u8* output) {
-	// this is now done from the ruby side
-	//char* filtered_input;
-	//filtered_input = (char*)malloc(input_length*sizeof(char));
-	//a85_filter_before_decode(input, input_length, filtered_input);
-	//int filtered_length = strlen(filtered_input);
-
     while (input_length) {
 
-		if (*input == 0) { break; }
-
-        if (*input >= 10 && *input <= 13) { input++; input_length--; continue; }
+        while ((*input >= 9 && *input <= 13) || *input == 32) { input++; input_length--;}
 
         if (input_length < 5) {
             // Determine represented value in base 85
             u32 val = 0;
             int factor = 52200625; // 85^4
+
             int i;
             for (i = 0; i < input_length; i++) {
                 val += (*(input++) - 33) * factor;
@@ -103,11 +90,16 @@ void a85_decode(const char* input, int input_length, u8* output) {
             break;
         }
 
-        // Determine represented value in base 85
+        // Determine represented value in base 85 while throwing out invalid ascii85 characters
+        while ((*input >= 9 && *input <= 13) || *input == 32) { input++; input_length--;}
         u32 val = (*(input++) - 33) * 52200625; // 85^4
+        while ((*input >= 9 && *input <= 13) || *input == 32) { input++; input_length--;}
         val += (*(input++) - 33) * 614125; // 85^3
+        while ((*input >= 9 && *input <= 13) || *input == 32) { input++; input_length--;}
         val += (*(input++) - 33) * 7225; // 85^2
+        while ((*input >= 9 && *input <= 13) || *input == 32) { input++; input_length--;}
         val += (*(input++) - 33) * 85; // 85^1
+        while ((*input >= 9 && *input <= 13) || *input == 32) { input++; input_length--;}
         val += (*(input++) - 33); // 85^0
 
         // Write out in big-endian order
@@ -117,4 +109,5 @@ void a85_decode(const char* input, int input_length, u8* output) {
         *(output++) = val;
         input_length -= 5;
     }
+	*(output++) = 0;
 }

data/ext/ascii85_native/ascii85_native.h

@@ -22,7 +22,3 @@ int a85_decoded_size(int input_length);
 // Translates the given Ascii85 input to binary output.
 // Can translate in-place.
 void a85_decode(const char* input, int input_length, u8* output);
-
-// Removes unused / ignored characters from the ascii85 input
-// TODO: identify and remove <~ and ~> delimiters
-void a85_filter_before_decode(const char* input, int input_length, char* output);

data/lib/ascii85_native.rb

@@ -17,13 +17,10 @@ module Ascii85Native
   #int a85_decoded_size(int textlen)
   attach_function :a85_decoded_size, [:int], :int
 
-  #void a85_decode(const char* text, int textlen, u8* data);
-  attach_function :a85_filter_before_decode, [:buffer_in, :int, :buffer_out], :void
-
   #void a85_decode(const char* text, int textlen, u8* data);
   attach_function :a85_decode, [:buffer_in, :int, :buffer_out], :void
 
-  attach_function :strlen, [:string], :int
+  attach_function :strlen, [:buffer_in], :int
 
   def self.encode(input, include_delimiter=false)
     if input.nil? || input.size == 0 
@@ -54,36 +51,31 @@ module Ascii85Native
   end
 
 
-  def self.decode(input, force_delimiter=true)
+  def self.decode(input, force_delimiter=false)
     return "" if input.nil? || input.size == 0
 
+    # Array slicing in ruby 3.0.1 appears to be constant time O(1): no performance hit based on array size.
+    # No reason to implement this code segment in C if this holds true.
     if force_delimiter
       input = input[2..-3]
     else
-      start_slice = find_start_slice(input)
-      end_slice = find_end_slice(input)
-      input = input[start_slice..end_slice] if start_slice != 0 || end_slice != -1
+      stream_start = find_stream_start(input)
+      stream_end = find_stream_end(input)
+      input = input[stream_start..stream_end] if stream_start != 0 || stream_end != -1
     end
 
     FFI::MemoryPointer.new(:char, input.size) do |in_char|
-      FFI::MemoryPointer.new(:char, input.size) do |filtered_char|
-        in_char.write_string(input)
-
-        self.a85_filter_before_decode(in_char, input.size, filtered_char)
-        filtered_length = self.strlen(filtered_char.read_string())
-        puts "filtered_length: #{filtered_length}"
-
-        out_size = self.a85_decoded_size(filtered_length)
+      in_char.write_string(input)
+      out_size = self.a85_decoded_size(input.size)
 
-        FFI::MemoryPointer.new(:uint8, out_size) do |output|
-          self.a85_decode(filtered_char, filtered_length, output)
-          return output.read_string()
-        end
+      FFI::MemoryPointer.new(:uint8, out_size) do |output|
+        self.a85_decode(in_char, strlen(in_char), output)
+        return output.read_string()
       end
     end
   end
 
-  def self.find_start_slice(input)
+  def self.find_stream_start(input)
     start_slice = 0
     cursor = 0 
 
@@ -102,7 +94,7 @@ module Ascii85Native
     return start_slice
   end
 
-  def self.find_end_slice(input)
+  def self.find_stream_end(input)
     end_slice = -1
     cursor = -1
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ascii85_native
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 1.0.2
 platform: ruby
 authors:
 - Jason Crossfield
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-06-04 00:00:00.000000000 Z
+date: 2021-06-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi