xot 0.3.14 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1f172e96fd93b17555e3ecb3c39e39bfdca41262542ac7a466da9d0447d0e40b
-  data.tar.gz: 02107f5e7b765ad11b7dd4a68f501d5c952e8cde8e0b1b1b4f3e2fd40c605311
+  metadata.gz: 7e347867590b9d9d97a002320ac500f075dde62556b0944b2a35705b415e2806
+  data.tar.gz: c684375fa42a755e7cef817aad1c658fd26f484b515876cb35323e56e1c313bd
 SHA512:
-  metadata.gz: 2049167fac1865e9aac0abe14692db36589471a30087711d35b7235f606173b21237fdb68864c3b00cb98367ad7f4f40f20ec7349273c86c5d725571c25d2f93
-  data.tar.gz: 840c347e7a028850081974a24807bee0f88bc3833186f12a4f9615ba810c669313d4f7d42ebc277b086bebc976b4a26f3b9c4cd46fdd1c0715007c593e1a434c
+  metadata.gz: d94d2378ba6835df631dd21ef26140f3cc43af8c370478d7b7c6ce0e6e433fd08deafa45810970995942e3f1a1f04f4343894aa9ce5c5a276c60f442f1faf0de
+  data.tar.gz: 2dd7f8827dd1804be81babfe7b89410f41a96b280ac57f30724c67b63b3356a2ab71cddb4d10465e4ee49c34450d1e5f961dff24a84931a89a0bbf5f60159cda

data/.github/workflows/release-gem.yml

@@ -26,8 +26,17 @@ jobs:
       - name: setup dependencies
         run: "ruby -I.github/workflows -rutils -e 'setup_dependencies'"
 
+      - name: packages
+        run: bundle exec rake packages
+
+      - name: setup zig
+        if: github.event.repository.name == 'reflex-terminal'
+        uses: mlugg/setup-zig@v2
+        with:
+          version: 0.16.0
+
       - name: test
-        run: bundle exec rake packages test
+        run: bundle exec rake test
 
       - name: create gem
         id: gem

data/.github/workflows/test.yml

@@ -27,6 +27,15 @@ jobs:
       - name: packages
         run: bundle exec rake verbose packages
 
+      - name: setup zig
+        if: github.event.repository.name == 'reflex-terminal'
+        uses: mlugg/setup-zig@v2
+        with:
+          version: 0.16.0
+
+      - name: vendor
+        run: bundle exec rake vendor
+
       - name: lib
         run: bundle exec rake verbose lib
 

data/ChangeLog.md

@@ -1,6 +1,20 @@
 # xot ChangeLog
 
 
+## [v0.4.0] - 2026-08-04
+
+- [BREAKING] Rework String conversions to std::wstring and CFString
+- Add a String constructor taking a pointer and a size
+- Add Xot.warn with a uniq option to suppress duplicate warnings
+- Let a source raise _WIN32_WINNT above the Windows 7 baseline
+
+
+## [v0.3.15] - 2026-06-23
+
+- Add WeakRef for weak references to RefCountable
+- Compile vendored C sources with the C compiler
+
+
 ## [v0.3.14] - 2026-06-12
 
 - Link static archive explicitly in export_all_symbols on ucrt32

data/VERSION

@@ -1 +1 @@
-0.3.14
+0.4.0

data/include/xot/defs.h

@@ -54,7 +54,7 @@ namespace Xot
 	}// Types
 
 
-	using namespace Types;
+	using namespace Xot::Types;
 
 
 }// Xot

data/include/xot/ref.h

@@ -28,6 +28,28 @@ namespace Xot
 	class EmptyClass {};
 
 
+	struct WeakRefCount : public NonCopyable
+	{
+
+		bool alive    = true;
+
+		int ref_count = 1;
+
+		void retain ()
+		{
+			++ref_count;
+		}
+
+		void release ()
+		{
+			assert(ref_count > 0);
+
+			if (--ref_count == 0) delete this;
+		}
+
+	};// WeakRefCount
+
+
 	template <typename SuperClass = EmptyClass>
 	class RefCountable : public SuperClass, public NonCopyable
 	{
@@ -61,6 +83,12 @@ namespace Xot
 				if (del) delete this;
 			}
 
+			WeakRefCount* get_weak_ref_count ()
+			{
+				if (!wref_count) wref_count = new WeakRefCount();
+				return wref_count;
+			}
+
 			virtual void* rucy_wrapper_value () const
 			{
 				return NULL;
@@ -86,12 +114,20 @@ namespace Xot
 
 			virtual ~RefCountable ()
 			{
+				if (wref_count)
+				{
+					wref_count->alive = false;
+					wref_count->release();
+					wref_count = NULL;
+				}
 			}
 
 		private:
 
 			mutable int refc_count = 0;
 
+			WeakRefCount* wref_count = NULL;
+
 			int refc_update_count (bool increment) const
 			{
 				int c = refc_count + (increment ? +1 : -1);
@@ -304,6 +340,115 @@ namespace Xot
 	};// Ref
 
 
+	template <typename T>
+	class WeakRef
+	{
+
+		typedef WeakRef<T> This;
+
+		typedef       T       Value;
+
+		typedef const T  ConstValue;
+
+		typedef       T&      Reference;
+
+		typedef const T& ConstReference;
+
+		typedef       T*      Pointer;
+
+		typedef const T* ConstPointer;
+
+		public:
+
+			WeakRef (Pointer ptr = NULL)
+			{
+				reset(ptr);
+			}
+
+			WeakRef (const This& obj)
+			{
+				reset(obj.ptr, obj.wref_count);
+			}
+
+			This& operator = (Pointer ptr)
+			{
+				reset(ptr);
+				return *this;
+			}
+
+			This& operator = (const This& obj)
+			{
+				if (&obj != this) reset(obj.ptr, obj.wref_count);
+				return *this;
+			}
+
+			~WeakRef ()
+			{
+				if (wref_count) wref_count->release();
+			}
+
+			void reset (Pointer ptr = NULL)
+			{
+				reset(ptr, ptr ? ptr->get_weak_ref_count() : NULL);
+			}
+
+			     Pointer get ()       {return wref_count && wref_count->alive ? ptr : NULL;}
+
+			ConstPointer get () const {return wref_count && wref_count->alive ? ptr : NULL;}
+
+			     Pointer operator -> ()       {return get();}
+
+			ConstPointer operator -> () const {return get();}
+
+			     Reference operator * ()       {return *get();}
+
+			ConstReference operator * () const {return *get();}
+
+			operator      Pointer ()       {return get();}
+
+			operator ConstPointer () const {return get();}
+
+			bool operator == (Pointer ptr) const {return get() == ptr;}
+
+			bool operator != (Pointer ptr) const {return !operator==(ptr);}
+
+			bool operator == (ConstPointer ptr) const {return get() == ptr;}
+
+			bool operator != (ConstPointer ptr) const {return !operator==(ptr);}
+
+			bool operator == (const This& obj) const {return get() == obj.get();}
+
+			bool operator != (const This& obj) const {return !operator==(obj);}
+
+			template <typename X>
+			bool operator == (const WeakRef<X>& obj) const {return get() == obj.get();}
+
+			template <typename X>
+			bool operator != (const WeakRef<X>& obj) const {return !operator==(obj);}
+
+			bool operator <  (const This& obj) const {return get() < obj.get();}
+
+			operator bool () const {return get();}
+
+			bool operator ! () const {return !operator bool();}
+
+		private:
+
+			void reset (Pointer ptr, WeakRefCount* count)
+			{
+				if (count)           count->retain();
+				if (wref_count) wref_count->release();
+				this->ptr        = ptr;
+				this->wref_count = count;
+			}
+
+			Pointer ptr = NULL;
+
+			WeakRefCount* wref_count = NULL;
+
+	};// WeakRef
+
+
 }// Xot
 
 

data/include/xot/string.h

@@ -26,7 +26,9 @@
 
 
 #if defined(OSX) || defined(IOS)
-	struct __CFString;
+
+struct __CFString;
+
 #endif
 
 
@@ -34,6 +36,13 @@ namespace Xot
 {
 
 
+#if defined(OSX) || defined(IOS)
+
+	typedef std::shared_ptr<const __CFString> CFStringPtr;
+
+#endif
+
+
 	class String : public std::string
 	{
 
@@ -45,6 +54,8 @@ namespace Xot
 
 			String (const char* str);
 
+			String (const char* str, size_t size);
+
 			String (const std::string& str);
 
 			template <typename ITERATOR>
@@ -64,6 +75,18 @@ namespace Xot
 
 			friend String operator + (const char*   lhs, const String& rhs);
 
+#if defined(OSX) || defined(IOS)
+
+			CFStringPtr to_cfstr () const;
+
+#elif defined(WIN32)
+
+			String (const wchar_t* str, size_t size);
+
+			std::wstring to_wstr () const;
+
+#endif
+
 	};// String
 
 
@@ -79,15 +102,6 @@ namespace Xot
 	template <typename T> String to_s (const T& val);
 
 
-#if defined(OSX) || defined(IOS)
-
-	typedef std::shared_ptr<const __CFString> CFStringPtr;
-
-	CFStringPtr cfstring (const char* str);
-
-#endif
-
-
 }// Xot
 
 

data/include/xot/windows.h

@@ -6,7 +6,11 @@
 
 #ifdef WIN32
 	#undef  _WIN32_WINNT
-	#define _WIN32_WINNT _WIN32_WINNT_WIN7
+	#ifdef XOT_WIN32_WINNT
+		#define _WIN32_WINNT XOT_WIN32_WINNT
+	#else
+		#define _WIN32_WINNT _WIN32_WINNT_WIN7
+	#endif
 	#include <windows.h>
 	#include <windowsx.h>
 #endif

data/lib/xot/extconf.rb

@@ -51,8 +51,8 @@ module Xot
       local_libs << 'stdc++' if gcc?
 
       $CPPFLAGS = make_cppflags $CPPFLAGS, defs, inc_dirs
-      $CFLAGS   = make_cflags   $CFLAGS   + ' -x c++'
-      $CXXFLAGS = make_cflags   $CXXFLAGS + ' -x c++' if $CXXFLAGS
+      $CFLAGS   = make_cxxflags $CFLAGS   + ' -x c++'
+      $CXXFLAGS = make_cxxflags $CXXFLAGS + ' -x c++' if $CXXFLAGS
       $LDFLAGS  = make_ldflags  ldflags, lib_dirs, frameworks
       $LOCAL_LIBS << local_libs.reverse.map {|s| " -l#{s}"}.join
     end

data/lib/xot/extension.rb

@@ -6,7 +6,7 @@ module Xot
     module_function
 
     def name(downcase = false)
-      super().split('::')[-2].then {|s|
+      super().split('::')[..-2].join.then {|s|
         downcase ? s.gsub(/([a-z])([A-Z])/) {"#{$1}-#{$2}"}.downcase : s
       }
     end

data/lib/xot/rake/util.rb

@@ -213,22 +213,28 @@ module Xot
       [root, RbConfig::CONFIG['rubyarchhdrdir'] || "#{root}/#{RUBY_PLATFORM}"]
     end
 
-    def make_cflags(flags = '')
-      warning_opts  = %w[no-unknown-pragmas]
-      warning_opts += %w[
+    def make_cflags(flags = '', std: 'gnu17', stdlib: nil)
+      warn_opts  = %w[no-unknown-pragmas]
+      warn_opts += %w[
         no-deprecated-register
         no-reserved-user-defined-literal
       ] if clang?
+
       s  = flags.dup
-      s << warning_opts.map {|s| " -W#{s}"}.join
-      s << " -arch arm64"                                          if osx? && arm64?
-      s << ' -std=c++20'                                           if gcc? || emcc?
-      s << ' -std=c++20 -stdlib=libc++ -mmacosx-version-min=10.10' if clang?
-      s << ' ' + RbConfig::CONFIG['debugflags']                    if debug?
-      s.gsub!(/-O\d?\w*/, '-O0')                                   if debug?
+      s << " -arch arm64"                       if osx? && arm64?
+      s << " -std=#{std}"                       if clang? || gcc? || emcc?
+      s << " -stdlib=#{stdlib}"                 if clang? && stdlib
+      s << ' -mmacosx-version-min=10.10'        if clang? && osx?
+      s << ' ' + RbConfig::CONFIG['debugflags'] if debug?
+      s.gsub!(/-O\d?\w*/, '-O0')                if debug?
+      s << warn_opts.map {|s| " -W#{s}"}.join
       s
     end
 
+    def make_cxxflags(flags = '')
+      make_cflags flags, std: 'c++20', stdlib: 'libc++'
+    end
+
     def make_ldflags(flags = '', libdirs = [], frameworks = [])
       s  = flags.dup
       s << libdirs.map    {|s| " -L#{s}"}.join
@@ -242,11 +248,17 @@ module Xot
       make_cppflags flags, defs, inc_dirs
     end
 
+    def cflags(warnings = true)
+      cflags = get_env :CFLAGS, RbConfig::CONFIG['CFLAGS']
+      cflags = cflags.gsub(/-W[\w\-\=]+/, '') + ' -w' unless warnings
+      make_cflags cflags
+    end
+
     def cxxflags(warnings = true)
       cflags   = get_env :CFLAGS,   RbConfig::CONFIG['CFLAGS']
       cxxflags = get_env :CXXFLAGS, RbConfig::CONFIG['CXXFLAGS']
       cflags   = cflags.gsub(/-W[\w\-\=]+/, '') + ' -w' unless warnings
-      make_cflags "#{cflags} #{cxxflags}"
+      make_cxxflags "#{cflags} #{cxxflags}"
     end
 
     def arflags()

data/lib/xot/rake.rb

@@ -327,7 +327,11 @@ module Xot
             unless get_env :VENDOR_NOCOMPILE, false
               vendor_srcs_map(*srcdirs).each do |src, obj|
                 rake_puts "compiling #{src}"
-                sh %( #{cxx} -c #{cppflags} #{cxxflags false} -o #{obj} #{src} )
+                if File.extname(src) == '.c'
+                  sh %( #{cc} -c #{cppflags} #{cflags false} -o #{obj} #{src} )
+                else
+                  sh %( #{cxx} -c #{cppflags} #{cxxflags false} -o #{obj} #{src} )
+                end
               end
             end
           end

data/lib/xot/util.rb

@@ -6,6 +6,15 @@ module Xot
 
   extend module Util
 
+    def warn(message, uniq: false)
+      if uniq
+        @warnings__ ||= {}
+        return if @warnings__[message]
+        @warnings__[message] = true
+      end
+      Kernel.warn message
+    end
+
     def get_env!(name, defval = nil)
       val = ENV[name.to_s] || Object.const_get(name) rescue defval
       val.dup rescue val

data/src/string.cpp

@@ -1,13 +1,16 @@
 #include "xot/string.h"
 
 
+#include <limits.h>
 #include <stdio.h>
 #include <string.h>
 #include <algorithm>
 #include "xot/exception.h"
 
 #if defined(OSX) || defined(IOS)
-#import <CoreFoundation/CoreFoundation.h>
+	#import <CoreFoundation/CoreFoundation.h>
+#elif defined(WIN32)
+	#include "xot/windows.h"
 #endif
 
 
@@ -24,6 +27,11 @@ namespace Xot
 	{
 	}
 
+	String::String (const char* str, size_t size)
+	:	Super(str, size)
+	{
+	}
+
 	String::String (const std::string& str)
 	:	Super(str)
 	{
@@ -88,6 +96,57 @@ namespace Xot
 		return t;
 	}
 
+#if defined(OSX) || defined(IOS)
+
+	static void
+	release_cfstring (CFTypeRef ref)
+	{
+		if (ref) CFRelease(ref);
+	}
+
+	CFStringPtr
+	String::to_cfstr () const
+	{
+		return CFStringPtr(
+			CFStringCreateWithCString(kCFAllocatorDefault, c_str(), kCFStringEncodingUTF8),
+			release_cfstring);
+	}
+
+#elif defined(WIN32)
+
+	String::String (const wchar_t* str, size_t size)
+	{
+		if (size > INT_MAX)
+			argument_error(__FILE__, __LINE__);
+		if (!str || size == 0) return;
+
+		int len = WideCharToMultiByte(CP_UTF8, 0, str, (int) size, NULL, 0, NULL, NULL);
+		if (len <= 0) system_error(__FILE__, __LINE__);
+
+		resize((size_t) len);
+		WideCharToMultiByte(CP_UTF8, 0, str, (int) size, &(*this)[0], len, NULL, NULL);
+	}
+
+	std::wstring
+	String::to_wstr () const
+	{
+		if (empty()) return std::wstring();
+
+		size_t size = this->size();
+		if (size > INT_MAX)
+			invalid_state_error(__FILE__, __LINE__);
+
+		int len = MultiByteToWideChar(CP_UTF8, 0, data(), (int) size, NULL, 0);
+		if (len <= 0) system_error(__FILE__, __LINE__);
+
+		std::wstring result;
+		result.resize((size_t) len);
+		MultiByteToWideChar(CP_UTF8, 0, data(), (int) size, &result[0], len);
+		return result;
+	}
+
+#endif
+
 
 	String
 	stringf (const char* format, ...)
@@ -199,21 +258,6 @@ namespace Xot
 		return to_s((CFStringRef) val.get());
 	}
 
-
-	static void
-	release_cfstring (CFTypeRef ref)
-	{
-		if (ref) CFRelease(ref);
-	}
-
-	CFStringPtr
-	cfstring (const char* str)
-	{
-		CFStringRef ref = CFStringCreateWithCString(
-			kCFAllocatorDefault, str, kCFStringEncodingUTF8);
-		return CFStringPtr(ref, release_cfstring);
-	}
-
 #endif
 
 

data/test/test_util.rb

@@ -0,0 +1,33 @@
+require_relative 'helper'
+require 'stringio'
+
+
+class TestUtil < Test::Unit::TestCase
+
+  def util()
+    Object.new.extend Xot::Util
+  end
+
+  def capture_stderr(&block)
+    stderr, $stderr = $stderr, StringIO.new
+    block.call
+    $stderr.string
+  ensure
+    $stderr = stderr
+  end
+
+  def test_warn()
+    u = util
+    assert_equal "x\nx\n", capture_stderr {u.warn "x"; u.warn "x"}
+  end
+
+  def test_warn_uniq()
+    u = util
+    assert_equal "x\ny\n", capture_stderr {
+      u.warn "x", uniq: true
+      u.warn "x", uniq: true
+      u.warn "y", uniq: true
+    }
+  end
+
+end# TestUtil

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: xot
 version: !ruby/object:Gem::Version
-  version: 0.3.14
+  version: 0.4.0
 platform: ruby
 authors:
 - xordog
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-06-12 00:00:00.000000000 Z
+date: 2026-08-04 00:00:00.000000000 Z
 dependencies: []
 description: This library include some useful utility classes and functions for development
   with C++.
@@ -81,6 +81,7 @@ files:
 - test/test_setter.rb
 - test/test_tester.rb
 - test/test_universal_accessor.rb
+- test/test_util.rb
 - xot.gemspec
 homepage: https://github.com/xord/xot
 licenses:
@@ -119,3 +120,4 @@ test_files:
 - test/test_setter.rb
 - test/test_tester.rb
 - test/test_universal_accessor.rb
+- test/test_util.rb