Make c_raii move-only and add some caveat comments

That's all I plan to do on `c_raii` for now... onward to other things...

Author: hsutter

include/cpp2util.h

@@ -702,8 +702,8 @@ class final_action_success
  }
  }
 
- final_action_success(final_action_success&& other) noexcept
- : f(std::move(other.f)), invoke(std::exchange(other.invoke, false))
+ final_action_success(final_action_success&& that) noexcept
+ : f(std::move(that.f)), invoke(std::exchange(that.invoke, false))
  { }
 
  final_action_success(final_action_success const&) = delete;
@@ -760,9 +760,10 @@ auto to_string(...) -> std::string {
 //
 // As part of embracing compatibility while also reducing what we have to
 // teach and learn about C++ (which includes the C standard library), I
-// want to see if we can improve use of the C standard library from Cpp2
-// code... UFCS is a big part of that, and then RAII destructors is
+// was curious to see if we can improve use of the C standard library
+// from Cpp2 code... UFCS is a part of that, and then RAII destructors is
 // another that goes hand in hand with that, hence this section...
+// but see caveat note at the end.
 //
 //-----------------------------------------------------------------------
 //
@@ -777,18 +778,34 @@ class c_raii {
  , dtor{ [](void* x) { (D)(x); } }
  { }
 
- ~c_raii() { dtor(t); }
+ ~c_raii() { if (dtor) dtor(t); }
 
  operator T&() { return t; }
 
- c_raii(c_raii const&)  = delete;
+ c_raii(c_raii const&) = delete;
  auto operator=(c_raii const&) = delete;
+ c_raii(c_raii&& that) : t {std::move(that.t)}, dtor {that.dtor} { that.dtor = nullptr; }
+ auto operator=(c_raii&& that) { t = std::move(that.t); dtor = that.dtor; that.dtor = nullptr; }
 };
 
 auto fopen( const char* filename, const char* mode ) {
- return c_raii( std::fopen(filename, mode), &fclose );
+ auto x = std::fopen(filename, mode);
+ if (!x) {
+ throw std::make_error_condition(std::errc::no_such_file_or_directory);
+ }
+ return c_raii( x, &fclose );
 }
 
+// Caveat: There's little else in the C stdlib that allocates a resource...
+//
+// malloc is already wrapped like this via std::unique_ptr, which
+// typically uses malloc or gets memory from the same pool
+// thrd_create std::jthread is better
+//
+// ... is that it? I don't think it's useful to provide a c_raii just for fopen,
+// but perhaps c_raii may be useful for bringing forward third-party C code too,
+// with cpp2::fopen as a starting example.
+
 
 }
 

source/sema.h

@@ -175,7 +175,7 @@ struct last_use {
  token const* t;
  bool is_forward;
  last_use( token const* t_, bool is_forward_ = false ) : t{t_}, is_forward{is_forward_} { }
- bool operator==(last_use const& other) { return t == other.t; }
+ bool operator==(last_use const& that) { return t == that.t; }
 };
 std::vector<last_use> definite_last_uses;