Replace `Nx()` (temp value-assigning) macros with `Nv()` to avoid conflict with `TRACEx()` and for more clarity.

(merge from `strings`)

Fortune for naka's current commit: Curse − 凶
master
Avril 3 years ago
parent a66da84047
commit 6bd747a57a

@ -44,6 +44,31 @@
#define restrict __restrict__ #define restrict __restrict__
#endif #endif
// Function conventions
#define _cconv__mixin _mixin
#define _cconv__pure _pure
#define _cconv__readonly _readonly
#define _cconv__cold _cold
#define _cconv__dead _dead
#define _cconv__unused _dead
#define _cconv__hot _hot
#define _cconv__entry __attribute__((constructor))
#define _cconv__exit __attribute__((destructor))
// Allocates
#define _cconv__alloc __attribute__((malloc))
// Infallible alloc
#define _cconv__ialloc __attribute__((malloc)) __attribute__((returns_nonnull))
#define _cconv__nonnull __attribute__((returns_nonnull))
#define _callcv(name) _cconv__ ## name
#define _callconv(name) _callcv(name)
#define _callat_entry _callcv(entry)
#define _callat_exit _callcv(exit)
#define _callat(when) _callat_ ## when
// Argument attribute // Argument attribute
// Used like: `int *pOUT output, const int *pIN input` // Used like: `int *pOUT output, const int *pIN input`
@ -110,6 +135,8 @@ _mixin void _drain_val(void* x, ...) { IGNORE(x); } // This compiles to no-op on
// Allocation macros // Allocation macros
#define box(t) aligned_alloc(_Alignof(t), sizeof(t)) #define box(t) aligned_alloc(_Alignof(t), sizeof(t))
#define box_value(v) ({ let _box = box(var(v)); *_box = (v); _box; })
#define unbox_value(v) ({ let _v = (v); let _res = *_v; free(_v); _res; })
#define stackalloc(t) __builtin_alloca_with_align(sizeof(t), _Alignof(t)) #define stackalloc(t) __builtin_alloca_with_align(sizeof(t), _Alignof(t))
// Function macros // Function macros
@ -236,4 +263,9 @@ static_assert_eq(bswap(bswap(128lu)), 128, "bswap128 (lu) failed (3)");
#define VERSION_REV(ver) _AS_u32(_AS_u32(ver) & 0xffu) #define VERSION_REV(ver) _AS_u32(_AS_u32(ver) & 0xffu)
_Static_assert( (VERSION_COMP(VERSION(1,2,3,4), VER_COMP_MIN) >> VER_COMP_MIN) == 2u, "invalid native version spec"); _Static_assert( (VERSION_COMP(VERSION(1,2,3,4), VER_COMP_MIN) >> VER_COMP_MIN) == 2u, "invalid native version spec");
// Misc.
#define PTR_ASSIGN(ptr, val) ( (ptr) ? (*(ptr) = (val), (ptr)) : (ptr) )
#define PTR_ASSIGNv(ptr, val) ({ let _ptr = (ptr); let _val = (val); PTR_ASSIGN(_ptr, _val); })
#endif /* _MACROS_H */ #endif /* _MACROS_H */

@ -11,8 +11,101 @@
#define FLAGSET(f, flag) (( (f) & (flag) ) == (flag)) #define FLAGSET(f, flag) (( (f) & (flag) ) == (flag))
#define DFLAGSET(f, flagname) FLAGSET(f, DISPF_SHOW_ ## flagname) #define DFLAGSET(f, flagname) FLAGSET(f, DISPF_SHOW_ ## flagname)
//TODO: This probably won't work. Write wrappers for strncpy(), strncat() that return number of bytes written isntead of useless pointer that we already have. #define CMP(x,cmp,y) ( (x) cmp (y) ? (x) : (y) )
static usize _display_get_fmt(dispflags_t flags, bool matched, usize _len, char str[pOUT _len]) #define CMPv(x,cmp,y) ({ let _x = (x); let _y = (y); CMP(_x, cmp, _y); })
#define MIN(x, y) CMP((x), <, (y))
#define MINv(x, y) CMPv((x), <, (y))
#define MAX(x, y) CMP((x), >, (y))
#define MAXv(x, y) CMPv((x), >, (y))
// Returns number of bytes written to `dest`. Otherwise same as `strncpy()`.
static usize strncpy_n(char*pOUT dest, const char* restrict src, usize n)
{
usize i;
for(i=0;i<n;i++)
if(! (*dest++ = *src++)) return i;
dest[i] = 0;
return i;
}
// Will not write past `dn` bytes of `dest`, will not read past `sn` bytes of `src`. Otherwise, same as `strncpy_n()`.
static usize s_strncpy_n(usize sn, usize dn; char dest[static pOUT dn], usize dn, const char src[static restrict sn], usize sn)
{
usize i;
usize n = MIN(sn,dn);
for(i=0;i<n;i++)
if(! (*dest++ = *src++)) return i;
if(i<dn) dest[i] = 0;
return i;
}
// Will not write past `dn` bytes of `dest`, will not read past `sn` bytes of `src`. Otherwise, same as `strncat_n()`.
static inline usize s_strncat_n(usize sn, usize dn; char dest[static pOUT dn], usize dn, const char src[static restrict sn], usize sn)
{
usize dl = MINv(strlen(dest), dn);
return s_strncpy_n(dest + dl, dn - dl, src, sn);
}
// Returns number of bytes written to (dest+strlen(dest)). Otherwise same as `strncat()`.
static inline usize strncat_n(char*pOUT dest, const char* restrict src, usize n)
{
usize dl = strlen(dest);
return strncpy_n(dest+dl, src, n);
}
//TODO: This isn't working at all...
#ifdef _DEBUG_USE_UNSAFE_DISPLAY_FMT_ARGS
_dead
#endif
static usize _display_get_fmt_n(dispflags_t flags, bool matched, usize _n, char str[pOUT _n])
{
register usize n = _n, fw=0;
const char* fmts[] = {
DFLAGSET(flags, FAILURES)
? "failure: "
: "",
"match: ",
"%lu: ",
SLICE_FORMAT,
" (len %lu)",
(const char*)NULL,
};
usize w = s_strncpy_n(str, n, fmts[!!matched], n); // SAFETY: Will never read past `fmts[x]` nul-terminator, so setting n as both dest and src length here is safe.
//TODO: Fix this... It isn't working...
#define ADDSTR(s) do { \
debug_assert((s)); \
w = MINv(s_strncat_n(str, n, (s), n), n); \
/* Remove written from `n` */ \
n -= w; \
/* Check if we have written into the limit (if so, w will be equal to n above, since w is high-bounded to n by `MINv()` above. So if n is 0, we have hit the limit. */ \
ifU(!n) { \
/*XXX: Should this be `str[w-1]?` If this assert fails then yes it should. */ \
debug_assert(w < _n); \
str[w] = 0; \
return fw + w; \
} \
/* Increase `str` pointer by written */ \
str += w; \
/* Increase return value by written. */ \
fw += w; \
} while(0)
if(DFLAGSET(flags, NUMBER)) ADDSTR(fmts[2]);
if(DFLAGSET(flags, SLICE)) ADDSTR(fmts[3]);
if(DFLAGSET(flags, LENGTH)) ADDSTR(fmts[4]);
ADDSTR("\n");
TRACE("Output string written: %lu, (rlen %lu)", fw, n);
#undef ADDSTR
return fw;
}
//XXX: This works, but seems inherantly unsafe. Rewrite to use the above `strn*_n()` functions for better length tracking.
#ifndef _DEBUG_USE_UNSAFE_DISPLAY_FMT_ARGS
_dead deprecated_message("this is unsafe, use `_display_get_fmt_n`")
#endif
static usize _display_get_fmt0(dispflags_t flags, bool matched, usize _len, char str[pOUT _len])
{ {
register usize len = _len; register usize len = _len;
static const char* fmts[] = { "match: ", "%lu: ", SLICE_FORMAT, " (len %lu)", "failure: ", (const char*)NULL }; static const char* fmts[] = { "match: ", "%lu: ", SLICE_FORMAT, " (len %lu)", "failure: ", (const char*)NULL };
@ -30,6 +123,12 @@ static usize _display_get_fmt(dispflags_t flags, bool matched, usize _len, char
#undef ADDSTR #undef ADDSTR
} }
#ifdef _DEBUG_USE_UNSAFE_DISPLAY_FMT_ARGS
#define _display_get_fmt(...) _display_get_fmt0(__VA_ARGS__)
#else
#define _display_get_fmt(...) _display_get_fmt_n(__VA_ARGS__)
#endif
static void _display_normal(FILE* output, dispin_t*pIN input, dispflags_t flags) static void _display_normal(FILE* output, dispin_t*pIN input, dispflags_t flags)
{ {
bool matched = input->matched; bool matched = input->matched;
@ -49,9 +148,14 @@ static void _display_normal(FILE* output, dispin_t*pIN input, dispflags_t flags)
#endif #endif
INFO("Mapped region slice for %lu, pre-transform (at %p): " SLICE_FORMAT ", len: %lu", i+1, base, SLICE_FORMAT_ARGS(&cslice), cslice.len); INFO("Mapped region slice for %lu, pre-transform (at %p): " SLICE_FORMAT ", len: %lu", i+1, base, SLICE_FORMAT_ARGS(&cslice), cslice.len);
//Honour `flags` // --- get format string from `flags` ---
char fmt[200]; //TODO: Find the realistic max for this. char fmt[200]; //TODO: Find the realistic max for this.
fmt[_display_get_fmt(flags, matched, 100, fmt)] = 0; usize fmtw = _display_get_fmt(flags, matched, sizeof(fmt)-1, fmt);
assert(fmtw+1 < sizeof(fmt));
fmt[fmtw+1] = 0;
// ---
TRACE("Format string get: `%s' (%lu)", fmt, fmtw);
fprintf(output, fmt, i+1, pos.start, pos.end, pos.end-pos.start); fprintf(output, fmt, i+1, pos.start, pos.end, pos.end-pos.start);
} }

Loading…
Cancel
Save