bitfield | Python fast integer set implementation | Machine Learning library

There's no apparent reason why. I very much doubt these libs are meant to be shared with 8- or 16 bitters, which would be the only sensible explanation.

A Cortex M will be 32 bit with 32 bit int and 32 bit long. And most importantly 32 bit hardware peripheral registers. So even if long was 64 bit it would be senseless to shift a mask outside the register bounds.

The U suffix is enough to prevent undefined behavior left shifts on a signed operand. Other sloppy libs use the bugged 1 << n style, so maybe 1UL was a quick fix to correct that bug - where 1U would have worked just as fine.

Any ideas of the correct way to write the following code?

There is no correct way. It's not possible to use static_assert to check if bitfields are in specific places.

You are using C++. Do not use an union. Write a normal class with accessors that access specific bits with masks - such way is clear, portable and guaranteed to work. Alternatively use a std::bitset.

I question the following assumption:

This didn't work. It is clear that the compiler is optimising-out much of the code related to z completely! The code then fails to function properly (running far too fast), and the size of the compiled binary drops to about 50% or so.

Looking at https://gcc.godbolt.org/z/sKdz3h8oP, it seems like the loops are actually being performed, however, for whatever reason each z++, when using a global volatile z goes from:

Sketch.cpp is compiled as as C++, including test.h. In order to support function overloading, class membership etc, C++ uses name mangling to encode these C++ features in the symbol name. As such the symbol name for some_test in Sketch.cpp is not the same as that in test.c which is compiled as C and no name mabgling is applied..

The solution is to prevent name mangling for this symbol when the header is C++ compiled by specifying that the symbol has C linkage:

RoleData.permissions is a PermissionResolvable or an array of PermissionResolvable and not an object .

If you don't want to grant any permissions to the newly created role, you can do

The reason they have different amount of lines is because they are two different things. message.author is a User, but what's stored in the db is a GuildMember. What's the difference?

The reason that message.author has User in front of it is that it's a class. What's in the db was originally a class, and would've been logged with GuildMember in front of it, however you unfortunately cannot keep classes in quick.db. Nor should you want to, as it would take up an insane amount of storage. Methods such as #send are only available on the GuildMember class (as opposed to the GuildMember class turned into an object by quick.db), so you can't access it from the db.

Instead, store the user ID in the db, as it's a unique identifier and you can get the user from it without storing huge objects in a db. You can use client.users.fetch(id) to get the user.

Could you let us know what is being logged to the console from the console.log(member)?

My best bet would be that the WELCOME_CHANNEL_ID is wrong and thus returning a bogus channel.

If that is not the case, then maybe the bot is not caching the channels, so use this:

I found that the following works to force word-wise reads and writes.

Structure:

You can use -o /dev/null to discard the output altogether, or you could send it to a temporary file which you then delete. If you're concerned with compile times, you can add -E in order to only run the preprocessor, which is the minimum in order for -H to work. That works because if you tell gcc to stop after preprocessing (-H), it doesn't matter if you also tell it to stop after creating an object file (-c). (That's an exception to the general rule that gcc uses the last of a set of conflicting options, which is designed to let you override options by adding to the end of a command-line.)

However, I can't help thinking that this is not really the best solution to your problem. It seems like you've hand-crafted a compiler invocation with a number of options, and then put it somewhere where it's difficult to modify. A better solution would be to use a makefile and set the value of the various standard makefile variables -- such as CFLAGS, CPPFLAGS, LDFLAGS, LDLIBS -- which are documented in the Gnu make manual. In simple cases, your Makefile might consist only of lines which set these variables, since Gnu make has built-in rules for common targets.