Daan De Meyer
74d392ed1b
Drop the -fundamental suffix from src/fundamental/ headers in favor of names
that match their src/basic/ or src/shared/ counterparts (e.g.
macro-fundamental.h -> macro.h, assert-fundamental.h -> assert-util.h,
cleanup-fundamental.h -> cleanup-util.h). Rename src/basic/{btrfs,label}.{c,h}
to use the -util suffix to match the existing shared/btrfs-util and
shared/label-util siblings. Rename src/shared/mkdir-label.{c,h} to mkdir.{c,h}
and src/shared/tmpfile-util-label.{c,h} to tmpfile-util.{c,h} to match the
corresponding src/basic names.
This saves us from having to come up with separate names for files that do
the same thing across tiers, and it makes it easier to move stuff between
src/fundamental, src/basic and src/shared: consumers just #include "foo.h"
and pick up whichever tier their -I path resolves to first, so call sites
don't need to be updated when an API moves between layers.
Where a higher-tier wrapper exists (e.g. src/basic/macro.h wrapping
src/fundamental/macro.h), the wrapper uses an explicit "../fundamental/foo.h"
or "../basic/foo.h" relative include for the lower-tier header. We can't use
GCC's #include_next directive for this — when the wrapper is reachable both
via same-dir-as-source lookup and via -I (e.g. -Isrc/shared) for the
directory it lives in, #include_next advances by exactly one slot in libcpp's
internal directory chain and lands on the same physical directory it was
already in, never reaching the lower-tier sibling (see make_cpp_dir() in
gcc/libcpp/files.cc:1986).
To make sure the right headers are always picked up, the include directories
are reordered so that e.g. src/shared always takes priority over src/basic and
similar for the other directories.
Co-developed-by: Claude Opus 4.7 <noreply@anthropic.com>
106 lines
5.4 KiB
C
106 lines
5.4 KiB
C
/* SPDX-License-Identifier: LGPL-2.1-or-later */
|
|
#pragma once
|
|
|
|
#include "../fundamental/assert-util.h"
|
|
#include "../fundamental/cleanup-util.h" /* IWYU pragma: export */
|
|
|
|
typedef void (*free_func_t)(void *p);
|
|
typedef void* (*mfree_func_t)(void *p);
|
|
|
|
#define free_and_replace_full(a, b, free_func) \
|
|
({ \
|
|
typeof(a)* _a = &(a); \
|
|
typeof(b)* _b = &(b); \
|
|
free_func(*_a); \
|
|
*_a = *_b; \
|
|
*_b = NULL; \
|
|
0; \
|
|
})
|
|
|
|
/* This is similar to free_and_replace_full(), but NULL is not assigned to 'b', and its reference counter is
|
|
* increased. */
|
|
#define unref_and_replace_new_ref(a, b, ref_func, unref_func) \
|
|
({ \
|
|
typeof(a)* _a = &(a); \
|
|
typeof(b) _b = ref_func(b); \
|
|
unref_func(*_a); \
|
|
*_a = _b; \
|
|
0; \
|
|
})
|
|
|
|
#define _DEFINE_TRIVIAL_REF_FUNC(type, name, scope) \
|
|
scope type *name##_ref(type *p) { \
|
|
if (!p) \
|
|
return NULL; \
|
|
\
|
|
/* For type check. */ \
|
|
unsigned *q = &p->n_ref; \
|
|
assert(*q > 0); \
|
|
assert_se(*q < UINT_MAX); \
|
|
\
|
|
(*q)++; \
|
|
return p; \
|
|
}
|
|
|
|
#define _DEFINE_TRIVIAL_UNREF_FUNC(type, name, free_func, scope) \
|
|
scope type *name##_unref(type *p) { \
|
|
if (!p) \
|
|
return NULL; \
|
|
\
|
|
assert(p->n_ref > 0); \
|
|
p->n_ref--; \
|
|
if (p->n_ref > 0) \
|
|
return NULL; \
|
|
\
|
|
return free_func(p); \
|
|
}
|
|
|
|
#define DEFINE_TRIVIAL_REF_FUNC(type, name) \
|
|
_DEFINE_TRIVIAL_REF_FUNC(type, name,)
|
|
#define DEFINE_PRIVATE_TRIVIAL_REF_FUNC(type, name) \
|
|
_DEFINE_TRIVIAL_REF_FUNC(type, name, static)
|
|
#define DEFINE_PUBLIC_TRIVIAL_REF_FUNC(type, name) \
|
|
_DEFINE_TRIVIAL_REF_FUNC(type, name, _public_)
|
|
|
|
#define DEFINE_TRIVIAL_UNREF_FUNC(type, name, free_func) \
|
|
_DEFINE_TRIVIAL_UNREF_FUNC(type, name, free_func,)
|
|
#define DEFINE_PRIVATE_TRIVIAL_UNREF_FUNC(type, name, free_func) \
|
|
_DEFINE_TRIVIAL_UNREF_FUNC(type, name, free_func, static)
|
|
#define DEFINE_PUBLIC_TRIVIAL_UNREF_FUNC(type, name, free_func) \
|
|
_DEFINE_TRIVIAL_UNREF_FUNC(type, name, free_func, _public_)
|
|
|
|
#define DEFINE_TRIVIAL_REF_UNREF_FUNC(type, name, free_func) \
|
|
DEFINE_TRIVIAL_REF_FUNC(type, name); \
|
|
DEFINE_TRIVIAL_UNREF_FUNC(type, name, free_func);
|
|
|
|
#define DECLARE_TRIVIAL_REF_FUNC(type, name) \
|
|
type* name##_ref(type *p)
|
|
|
|
#define DECLARE_TRIVIAL_UNREF_FUNC(type, name) \
|
|
type* name##_unref(type *p)
|
|
|
|
#define DECLARE_TRIVIAL_REF_UNREF_FUNC(type, name) \
|
|
DECLARE_TRIVIAL_REF_FUNC(type, name); \
|
|
DECLARE_TRIVIAL_UNREF_FUNC(type, name)
|
|
|
|
#define DEFINE_PRIVATE_TRIVIAL_REF_UNREF_FUNC(type, name, free_func) \
|
|
DEFINE_PRIVATE_TRIVIAL_REF_FUNC(type, name); \
|
|
DEFINE_PRIVATE_TRIVIAL_UNREF_FUNC(type, name, free_func);
|
|
|
|
#define DEFINE_PUBLIC_TRIVIAL_REF_UNREF_FUNC(type, name, free_func) \
|
|
DEFINE_PUBLIC_TRIVIAL_REF_FUNC(type, name); \
|
|
DEFINE_PUBLIC_TRIVIAL_UNREF_FUNC(type, name, free_func);
|
|
|
|
typedef void (*void_func_t)(void);
|
|
|
|
static inline void dispatch_void_func(void_func_t *f) {
|
|
assert(f);
|
|
assert(*f);
|
|
(*f)();
|
|
}
|
|
|
|
/* Inspired by Go's "defer" construct, but much more basic. This basically just calls a void function when
|
|
* the current scope is left. Doesn't do function parameters (i.e. no closures). */
|
|
#define DEFER_VOID_CALL(x) _DEFER_VOID_CALL(UNIQ, x)
|
|
#define _DEFER_VOID_CALL(uniq, x) _unused_ _cleanup_(dispatch_void_func) void_func_t UNIQ_T(defer, uniq) = (x)
|