bitmask | A generic implementation of the BitmaskType C concept | File Utils library

The BIT_AND function has both arguments as numbers, and there is no bit vector.

For example:

It is not possible to have a reference or a pointer to a bit field. From cppreference :

Because bit fields do not necessarily begin at the beginning of a byte, address of a bit field cannot be taken. Pointers and non-const references to bit fields are not possible. When initializing a const reference from a bit field, a temporary is created (its type is the type of the bit field), copy initialized with the value of the bit field, and the reference is bound to that temporary.

And from the standard :

The address-of operator & shall not be applied to a bit-field, so there are no pointers to bit-fields. A non-const reference shall not be bound to a bit-field (dcl.init.ref).

And the accompanying note :

[Note 3: If the initializer for a reference of type const T& is an lvalue that refers to a bit-field, the reference is bound to a temporary initialized to hold the value of the bit-field; the reference is not bound to the bit-field directly. See dcl.init.ref. — end note]

The only reason this compiles is because tie takes the Bitmask type as const. Each of its bitfield members are treated as const and std::tie returns a std::tuple of const references. As the passage quoted above says, these references refer to copies of the data members, not those actual data members. Then, just like if you tried to return a const int & x = 10; by reference, you end up with a tuple of dangling references. Finally, trying to get the value of the referenced objects leads to Undefined Behavior.

How about something like:

Theoretically, It's impossible.

Suppose you got a set of CREATE_BITMASK, BITWISE_OP and JUDGEMENT that worked for all the integers in givenSet, so you must have:

Converting my comment to answer so that solution is easy to find for future visitors.

You may use this regex:

ODBC is how SWI Prolog connects to whatever database. I've just gone through this process once again for linking SWI Prolog to Postgresql, and it can be fiddly.

Firstly, you need to check this at the swipl command line:

You can and should use GNU C #include in your own code instead of GNU C inline asm. (How do I call "cpuid" in Linux?) Example on Godbolt of how it compiles, including the 32-bit mode check for CPUID availability.

x86-64 guarantees the availability of CPUID; you only need to check for it if your code might run on a 486 or earlier. But 486 can't run 64-bit code in the first place.

The actual problem with your code is that it doesn't try to flip the ID bit. Apparently 0 is normal for its current status. https://wiki.osdev.org/CPUID#Checking_CPUID_availability shows standard detection code (for 32-bit mode Intel-syntax, but easy enough to port) that uses a memory-destination XOR before a popf / pushf / pop reg to see if the setting "took". (Then it restores the original EFLAGS, which is probably unnecessary.)

For a GNU C inline asm implementation, see GCC's own cpuid.h (github) where it's done inside an #ifndef __x86_64__ block in __get_cpuid_max. It even has dialect-alternatives for AT&T vs. Intel-syntax, so code that uses #include doesn't break if compiled with -masm=intel.

Porting that to x86-64 would let you verify that it actually works, if you're curious.

Also, your push/pop is unsafe on Linux / Mac (x86-64 System V): you step on the red-zone. You need to add $-128, %rsp before and sub $-128, %rsp after, to avoid your push/pop stepping on the red-zone below the compiler's RSP, where it might be keeping local vars. See Using base pointer register in C++ inline asm

-128 fits in an imm8 but +128 doesn't, that's why I suggest add/sub $-128 instead of sub/add $128.

32 bits:

Bitwise operators treat their operands as a set of 32 bits (zeros and ones) and return standard JavaScript numerical values.

Specification:

6.1.6.1.9 Number::leftShift ( x, y )

1. Let lnum be ! ToInt32(x).
2. Let rnum be ! ToUint32(y).
3. Let shiftCount be the result of masking out all but the least significant 5 bits of rnum, that is, compute rnum & 0x1F.
4. Return the result of left shifting lnum by shiftCount bits. The result is a signed 32-bit integer.

LINQ joins are of the following form: