C#

{
  c = (c >> 1 & 0x55555555) + (c & 0x55555555);
  c = (c >> 2 & 0x33333333) + (c & 0x33333333);
  c = (c >> 4 & 0x0f0f0f0f) + (c & 0x0f0f0f0f);
  c = (c >> 8 & 0x00ff00ff) + (c & 0x00ff00ff);

  return (c >> 16) + (c & 0x0000ffff);
}

{
  // Atomic:
  position--;
  bit >>= 1;
}

lock(lockingVariable)
{
  position--;
  bit >= 1;
}

gggustafson wrote:

I am fiercely against this in a statement body

gggustafson wrote:

But in this case I think it signals atomicity. Is there a better way to do this?

// This operation is intended to be atomic.
position--;
bit >>= 1;

{ // These two operations are intended to be atomic.
  position--;
  bit >>= 1;
}

Block   Declaration

  1     [ DllImport ( "gdi32.dll", EntryPoint = "BitBlt" ) ]
        public static extern bool BitBlt ( IntPtr hdcDest, int nXDest,
                                  int nYDest, int nWidth, int nHeight, 
                                  IntPtr hdcSrc, int nXSrc, int nYSrc, 
                                  int dwRop );

  2     [ DllImport ( "gdi32.dll", 
                      EntryPoint = "BitBlt" ) ]
        public static extern bool BitBlt ( IntPtr hdcDest, 
                                           int    nXDest,
                                           int    nYDest, 
                                           int    nWidth, 
                                           int    nHeight, 
                                           IntPtr hdcSrc,
                                           int    nXSrc, 
                                           int    nYSrc, 
                                           int    dwRop );

bit = ( 1 << --position );

bit = ( 1 << --position );  // needs to be an atomic operation

atomic
    {
    :
    statements
    :
    }