/*
** Bit set, clear, and test operations
**
** public domain snippet by Bob Stout
*/
typedef enum {ERROR = -1, FALSE, TRUE} LOGICAL;
#define BOOL(x) (!(!(x)))
#define BitSet(arg,posn) ((arg) | (1L << (posn)))
#define BitClr(arg,posn) ((arg) & ~(1L << (posn)))
#define BitTst(arg,posn) BOOL((arg) & (1L << (posn)))
#define BitFlp(arg,posn) ((arg) ^ (1L << (posn)))
හරි, අපි දේවල් විශ්ලේෂණය කරමු ...
මේ සියල්ලෙහිම ඔබට ගැටළු ඇති බව පෙනෙන පොදු ප්‍රකාශනය වන්නේ "(1L << (posn))" යන්නයි. මේ සියල්ල කරන්නේ තනි බිට් එකක් සහිත වෙස්මුහුණක් නිර්මාණය කිරීම වන අතර එය ඕනෑම පූර්ණ සංඛ්‍යාවක් සමඟ ක්‍රියා කරයි. "පොස්න්" තර්කය මඟින් ඔබට අවශ්ය ස්ථානය නියම කරයි. Posn == 0 නම්, මෙම ප්‍රකාශනය පහත පරිදි ඇගයීමට ලක් කරයි:
0000 0000 0000 0000 0000 0000 0000 0001 binary.
Posn == 8 නම්, එය පහත පරිදි ඇගයීමට ලක් කරයි:
0000 0000 0000 0000 0000 0001 0000 0000 binary.
වෙනත් වචන වලින් කිවහොත්, එය හුදෙක් නිශ්චිත ස්ථානයේ 1 සමඟ 0 හි ක්ෂේත්‍රයක් නිර්මාණය කරයි. එකම උපක්‍රමශීලී කොටස වන්නේ බිට්ක්ලර් () මැක්‍රෝ තුළ වන අතර එහිදී අපට 1 ක ක්ෂේත්‍රයක තනි බිටු 0 ක් සැකසිය යුතුය. ටිල්ඩ් (~) ක්රියාකරු විසින් දැක්වෙන එකම ප්‍රකාශනයේ 1 හි අනුපූරකය භාවිතා කිරීමෙන් මෙය සිදු වේ.
වෙස්මුහුණ නිර්මාණය කළ පසු එය ඔබ යෝජනා කරන ආකාරයටම බිට්වේස් සහ (&), හෝ (|) සහ xor (^) ක්‍රියාකරුවන් භාවිතා කරයි. වෙස් මුහුණ දිගු වන බැවින්, මැක්රෝස් චාර්, ෂෝට්ස්, ඉන්ටර්ස් හෝ ලෝන්ග්ස් මතද ක්‍රියා කරයි.
අවසාන කරුණ නම් මෙය සමස්ත පන්තියේ ගැටලුවලට පොදු විසඳුමකි. ඇත්ත වශයෙන්ම, ඔබට අවශ්ය සෑම අවස්ථාවකම පැහැදිලි ආවරණ අගයන් සහිත මෙම මැක්රෝස් වලින් එකකට සමාන ප්‍රමාණයක් නැවත ලිවීම කළ හැකි නමුත් සුදුසු වන්නේ ඇයි? මතක තබා ගන්න, සාර්ව ආදේශනය සිදුවන්නේ පූර්ව සකසනය තුළ වන අතර එම නිසා ජනනය කරන ලද කේතය මඟින් සම්පාදකයා විසින් අගයන් නියත ලෙස සලකනු ලැබේ යන කාරණය පිළිබිඹු කරයි - එනම් ඔබට අවශ්ය සෑම අවස්ථාවකම “රෝදය ප්‍රතිනිර්මාණය කිරීම” සඳහා සාමාන්‍යකරණය කරන ලද මැක්රෝස් භාවිතා කිරීම කාර්යක්ෂම වේ. ටිකක් හැසිරවීම කරන්න.
එකඟ නොවන්නේද? මෙන්න පරීක්ෂණ කේත කිහිපයක් - මම සම්පූර්ණ ප්‍රශස්තිකරණයෙන් හා _cdecl භාවිතා නොකර වොට්කොම් සී භාවිතා කළෙමි.
---- [TEST.C] ----------------------------------------- -----------------------
#define BOOL(x) (!(!(x)))
#define BitSet(arg,posn) ((arg) | (1L << (posn)))
#define BitClr(arg,posn) ((arg) & ~(1L << (posn)))
#define BitTst(arg,posn) BOOL((arg) & (1L << (posn)))
#define BitFlp(arg,posn) ((arg) ^ (1L << (posn)))
int bitmanip(int word)
{
word = BitSet(word, 2);
word = BitSet(word, 7);
word = BitClr(word, 3);
word = BitFlp(word, 9);
return word;
}
---- [TEST.OUT (විසුරුවා හරින ලද)] -------------------------------------- ---------
Module: C:\BINK\tst.c
Group: 'DGROUP' CONST,CONST2,_DATA,_BSS
Segment: _TEXT BYTE 00000008 bytes
0000 0c 84 bitmanip_ or al,84H ; set bits 2 and 7
0002 80 f4 02 xor ah,02H ; flip bit 9 of EAX (bit 1 of AH)
0005 24 f7 and al,0f7H
0007 c3 ret
No disassembly errors
---- [finis] ------------------------------------------- ----------------------
