xot 0.3.14 → 0.3.15

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1f172e96fd93b17555e3ecb3c39e39bfdca41262542ac7a466da9d0447d0e40b
-  data.tar.gz: 02107f5e7b765ad11b7dd4a68f501d5c952e8cde8e0b1b1b4f3e2fd40c605311
+  metadata.gz: fb5106dfe6e2a51aa5564dd80ef829359effc9975343a86a6c7e06b858627976
+  data.tar.gz: e10270555bcf1fbbafb4d8c5a38808be5384b5c319b6bdac38c8ef34078ed4df
 SHA512:
-  metadata.gz: 2049167fac1865e9aac0abe14692db36589471a30087711d35b7235f606173b21237fdb68864c3b00cb98367ad7f4f40f20ec7349273c86c5d725571c25d2f93
-  data.tar.gz: 840c347e7a028850081974a24807bee0f88bc3833186f12a4f9615ba810c669313d4f7d42ebc277b086bebc976b4a26f3b9c4cd46fdd1c0715007c593e1a434c
+  metadata.gz: f77793be260e041b0acca7a8603191a661bf79b90539d41d60cee109bca721c0d83b268e3f2b44a966ee47bab2f99d8e825b7939e6afa10ac2bba26f819b7c10
+  data.tar.gz: ff16e23f9bac7b71a8864147f17211412a33a7c8ac1ee83ba2089a66567c95a46a7c4c6457a271046e9b588ef868409fa9761c0c80ac6ce938284e754879c4cf

data/ChangeLog.md

@@ -1,6 +1,12 @@
 # xot ChangeLog
 
 
+## [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.3.15

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/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/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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: xot
 version: !ruby/object:Gem::Version
-  version: 0.3.14
+  version: 0.3.15
 platform: ruby
 authors:
 - xordog
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-06-12 00:00:00.000000000 Z
+date: 2026-06-22 00:00:00.000000000 Z
 dependencies: []
 description: This library include some useful utility classes and functions for development
   with C++.