class CMyClass {
public:
        int PublicVar;

        CMyClass();
private:
        int privateVar;

        void privateMetod();
}

//comment
void f()
{
      int a;
      if(0 == a) {
            a++;
      } else {
            a--;
      }

      int b;
      switch(b) {                                      //comment
      case 1:
            a--;
            break;
      }
                                                            //comment     
}

void _usart_rx_ISR(void){
        _BIC_SR(GIE); // запрещаем прерывания
        b = U0RXBUF;
        if(p.c == 0){ // начало принятия пакета
                if(b == STARTBIT){
                        RESET_count;
                        paket[0] = STARTBIT;
                        p.c = 1;
                }
        }else{
                if(p.c == 7){
                        if(b == STOPBIT){
                                // проверим КС
                                if(_CRC8){
                                        p.c = 0;
                                        PACKET_READY;
                                        ME1 &= ~(URXE0); // отключаем ресивер
                                        _BIS_SR(GIE); // разрешаем прерывания
                                        return;
                                }
                        }
                }
                if(p.c == MAX_PACKETSIZE-1){
                        if(b == STOPBIT){
                                if(_CRC24()){
                                        p.c = 0;
                                        PACKET_READY;
                                        ME1 &= ~(URXE0); // отключаем ресивер
                                }else p.c = 0;
                        }else p.c = 0;
                }else{
                        paket[p.c++] = b;
                        RESET_count;
                }
        }
        _BIS_SR(GIE); // разрешаем прерывания
}

#define SECTOR_SIZE      512


enum ErrorType
{
    Err_OK,
    Err_Fail
};


//////////////////////////////////////////////////////////////////////////
// IHardDriveHAL, some comments there
//////////////////////////////////////////////////////////////////////////
class IHardDriveHAL   // abstract
{
public:
    bool    read_sector( void *buffer ) = 0;                    // comments
    bool    write_sector( void *buffer ) = 0;                   // comments
};


//////////////////////////////////////////////////////////////////////////
// FlashHAL, some comments there
//////////////////////////////////////////////////////////////////////////
class FlashHAL : public IHardDriveHAL
{
public:
    bool    read_sector( void *buffer );                        // comments
    bool    write_sector( void *buffer );                       // comments

    //...
};


//////////////////////////////////////////////////////////////////////////
// FlashDrive, some comments there
//////////////////////////////////////////////////////////////////////////
class FlashDrive
{
public:
    FlashDrive();
    ~FlashDrive();

    ErrorType   read_buffer( void *buffer, size_t length );     // comments
    ErrorType   write_buffer( void *buffer, size_t length );    // comments

private:
    IHardDriveHAL *_hal;
};




// Это уже в .cpp

//////////////////////////////////////////////////////////////////////////
// FlashDrive implementation
//////////////////////////////////////////////////////////////////////////

FlashDrive::FlashDrive()
    : _hal( NULL )
{
    _hal = new FlashHAL();
    // ...
}


// read_buffer, some comments there
ErrorType FlashDrive::read_buffer( void *buffer, size_t length )
{
    unsigned char buf[SECTOR_SIZE];
    unsigned char *user_buf = reinterpret_cast<unsigned char*>( buffer );

    for ( size_t read_len = 0; read_len < length; read_len += SECTOR_SIZE )
    {
        if ( length - read_len >= SECTOR_SIZE )
        {
            if ( !_hal->read_sector( user_buf ) )       // comments
                return Err_Fail;
            user_buf += SECTOR_SIZE;                    // comments
        }
        else
        {
            if ( !_hal->read_sector( buf ) )
                return Err_Fail;
            memcpy( user_buf, buf, length - read_len );
        }
    }
}

IOReturn PLX9080::plxOpenDevice(PLX9080::CallbackWOReturn init, PLX9080::CallbackWOReturn start, UInt32 data_addr,
                           UInt32 flags, bool complete)
{
   DbgPrint("PLX9080::plxOpenDevice(), users %d\n", masterIface_.users);
   if (masterIface_.users == 0)   //first called
   {
      set_bit(0, &masterIface_.dma_done);
      //Creating DMA struct
      masterIface_.dma = PLXDMAEngine::plxAlloc(data_addr,
                        masterIface_.buffers,
                        masterIface_.bufsize,
                        (masterIface_.direction == MASTER_DIRECTION_TX) ?
                        PCI_DMA_TODEVICE : PCI_DMA_FROMDEVICE,
                        flags/*,
                        complete*/);
      if (!masterIface_.dma)
      {
         return kIOReturnNoMemory;
      }
      //Initialization
      if (init) (this->*init)();
      if (start) (this->*start)();
      
      masterDev_.int_source->enable();
   }
   masterIface_.users++;
   
   return kIOReturnSuccess;
}

IOReturn PLX9080::plxRelease(PLX9080::CallbackWOReturn stop, PLX9080::CallbackWOReturn exit)
{
   DbgPrint("PLX9080::plxRelease(), users %d\n", masterIface_.users);
   if (masterIface_.users == 1)
   {
      masterDev_.int_source->disable();
      if (stop) (this->*stop)();
      if (exit) (this->*exit)();
      //Destroying DMA
      PLXDMAEngine::plxFree(masterIface_.dma);
   }
   masterIface_.users--;
   return kIOReturnSuccess;
}

if (x==y)
{
...
}
else if (x1==y1)
{
...
}
else
{
...
}
//что-то мелкое
if (zcv) fdfds;