complex a, b, c, d;
....
a += b - c*d;

a = complex_add(a, complex_sub(b, complex_mul(c, d)));

int DoSomething()
{
  CriticalSection cs;
  ...bla-bla-bla...
  if (foo)
    return 1;
  ...bla-bla-bla...
  if (bar)
    return 2;
  ...bla-bla-bla...
  if (baz)
    return 3;
  ...bla-bla-bla...
  return 0;
}

int DoSomething()
{
  DisableInterrupts();
  ...bla-bla-bla...
  if (foo) {
    RestoreInterrupts();
    return 1;
  }
  ...bla-bla-bla...
  if (bar) {
    RestoreInterrupts();
    return 2;
  }
  ...bla-bla-bla...
  if (baz) {
    RestoreInterrupts();
    return 3;
  }
  ...bla-bla-bla...
  RestoreInterrupts();
  return 0;
}

int DoSomething()
{
  UREG result=0;
  ATOMIC_BLOCK(_нужный_режим_)
  {
    ...bla-bla-bla...
    if (foo) {
                  result=1;continue;
    }
    ...bla-bla-bla...
    if (bar) {
                  result=2;continue;
    }
    ...bla-bla-bla...
    if (baz) {
                  result=3;continue;
    }
  }
  return result;
}

#pragma inline=forced
UREG __get_state_and_cli(void)
{
  UREG v=__save_interrupt();
  __disable_interrupt();
  return v;
}

#define ATOMIC_BLOCK() for(UREG __iter=0,__state=__get_state_and_cli();!__iter;__restore_interrupt(__state),__iter++)


void TestAtomic(void)
{
  ATOMIC_BLOCK()
  {
    OSCCAL++;
  }
}

volatile int ff;

int main (void) __attribute__((OS_main));

int main (void)
{
ATOMIC_BLOCK(ATOMIC_RESTORESTATE)
{
DDRB = 1;
if(ff) goto aaa;
PORTB=1;
}
ff += 41*DDRB;
aaa:
for(uint8_t j=0; j<3;j++)
{
ff += pgm_read_byte(&(BCD[j]));
}


return 0;
}

00000070 <main>:

int main (void) __attribute__((OS_main));

int main (void)
{
ATOMIC_BLOCK(ATOMIC_RESTORESTATE)
70: 2f b7 in r18, 0x3f ; 63
return 1;
}

static __inline__ uint8_t __iCliRetVal(void)
{
cli();
72: f8 94 cli
{
DDRB = 1;
74: 31 e0 ldi r19, 0x01 ; 1
76: 34 b9 out 0x04, r19 ; 4
if(ff) goto aaa;
78: 80 91 08 01 lds r24, 0x0108
7c: 90 91 09 01 lds r25, 0x0109
80: 89 2b or r24, r25
82: 09 f0 breq .+2 ; 0x86 <main+0x16>
84: 39 c0 rjmp .+114 ; 0xf8 <main+0x88>
PORTB=1;
86: 35 b9 out 0x05, r19 ; 5
(void)__s;
}

static __inline__ void __iRestore(const uint8_t *__s)
{
SREG = *__s;
88: 2f bf out 0x3f, r18 ; 63
}
ff += 41*DDRB;
8a: 80 91 08 01 lds r24, 0x0108
8e: 90 91 09 01 lds r25, 0x0109
92: 24 b1 in r18, 0x04 ; 4
94: 49 e2 ldi r20, 0x29 ; 41
96: 24 9f mul r18, r20
98: 90 01 movw r18, r0
9a: 11 24 eor r1, r1
9c: 28 0f add r18, r24
9e: 39 1f adc r19, r25
a0: 30 93 09 01 sts 0x0109, r19
a4: 20 93 08 01 sts 0x0108, r18
aaa:
for(uint8_t j=0; j<3;j++)
{
ff += pgm_read_byte(&(BCD[j]));
a8: 80 91 08 01 lds r24, 0x0108
ac: 90 91 09 01 lds r25, 0x0109
b0: e4 e3 ldi r30, 0x34 ; 52
b2: f0 e0 ldi r31, 0x00 ; 0
b4: 24 91 lpm r18, Z+
b6: 82 0f add r24, r18
b8: 91 1d adc r25, r1
ba: 90 93 09 01 sts 0x0109, r25
be: 80 93 08 01 sts 0x0108, r24
c2: 80 91 08 01 lds r24, 0x0108
c6: 90 91 09 01 lds r25, 0x0109
ca: 31 96 adiw r30, 0x01 ; 1
cc: 24 91 lpm r18, Z+
ce: 82 0f add r24, r18
d0: 91 1d adc r25, r1
d2: 90 93 09 01 sts 0x0109, r25
d6: 80 93 08 01 sts 0x0108, r24
da: 80 91 08 01 lds r24, 0x0108
de: 90 91 09 01 lds r25, 0x0109
e2: 31 96 adiw r30, 0x01 ; 1
e4: e4 91 lpm r30, Z+
e6: 8e 0f add r24, r30
e8: 91 1d adc r25, r1
ea: 90 93 09 01 sts 0x0109, r25
ee: 80 93 08 01 sts 0x0108, r24
}


return 0;
}
f2: 80 e0 ldi r24, 0x00 ; 0
f4: 90 e0 ldi r25, 0x00 ; 0
f6: 08 95 ret
f8: 2f bf out 0x3f, r18 ; 63
__asm__ volatile ("" ::: "memory");
fa: d6 cf rjmp .-84 ; 0xa8 <main+0x38>

какие-то действия
if( условие )
{
   ***
}
else
{
  ***
}

какие-то действия
if( условие )
{
   uint32_t count;
   ***
}
else
{
  ***
}

uint32_t count;
какие-то действия
if( условие )
{
   *** (тут count используется)
}
else
{
  *** (тут count не используется)
}

if( условие )
{
   uint32_t count;
   ***
}
else
{
  ***
}

switch( aaa )
{
    case bbb:
    {
        uint32_t count;
        ***
    }
    break;
    case ccc:
    {
        float sum;
        ***
    }
    break;
}

какие-то действия
if (условие) {
   uint32_t count = SOME_VALUE; // какое-то нужно Вам значение
   ***
}
else {
  ***
}

uint32_t count;
какие-то действия
if( условие )
{
   *** (тут count используется)
}
else
{
  *** (тут count не используется)
}
***
(тут count не используется)

class MtxKeypad
{
private:
  volatile KeyMapType NewKeyMap;   //  считываемая в данный момент карта клавиш
public:
  volatile KeyMapType KeyMap;       // последняя считанная карта клавиш

  // typedef Mtx_Button<1,1> Key_1;        // !! эти строки относятся к вопросу сабжа
// typedef Mtx_Button<1,2> Key_2;        // тут объявляются все кнопки и их расположение (строка,столбец)
// typedef Mtx_Button<2,1> Key_Enter;    
// typedef Mtx_Button<4,1> Key_Cancel;

  void Scan() {  // метод опроса клавиатуры
// ....
      KeyMap=NewKeyMap;
// ....
  }
};

template <int Col, int Row>
class Mtx_Button : public MtxKeypad
{
    //friend class MtxKeypad;    // это вот ХЗ надо тут или нет
private:
static const KeyMapType mask=(1UL<<(Row*5+Col));
public:
  inline uint8_t Pressed() {return (MtxKeypad::KeyMap & mask)!=0;}
};

int main()
{
    MtxKeypad Keys;
    Mtx_Button<4,1> Key_A;
    for(;;)
    {
        Keys.Scan();
        if(MtxKeypad::Key_1::Pressed()) pin2.Toggle();  // ошибка
        if(Key_A.Pressed()) pin2.Toggle();  // работает если добавить Key_A.Scan(); но тут отдельный объект с отдельными переменными - неправильно
    }
}

// шаблон кнопки
template<int row, int col, typename matrix>
class button
{
private:
    matrix& m_;  // ссылка на клавиатуру
public:
    button(matrix& M): m_(M) {}
    bool pressed() { return m_.keymap & (row*5+col); }
};

// класс клавиатуры
class kbd
{
public:
    button<0, 0, kbd> Enter(this);
    void Scan();
}

void main()
{
    kbd Kbd;
    Kbd.Scan();
    if (Kbd.Enter.presed())
    {
    }
}

#define putnstr(str,n)  do {            \
        printf ("%.*s", n, str);    \
    } while (0)

#define func(a) do { aa(a); bb(a); } while(0)
#define func2(a) { aa(a); bb(a); }

if (some) func(a); else blablabla(a); // Ok
if (some) func2(a); else blablabla(a); // Syntax error

do { aa(a); bb(a); } while(0)

if (1)
{
};
else
{
}

if(1)
{
   foo1();
}
foo2();
else
{
}

#include "file2.h"

typedef struct
{
   ...
   ..
   .
   some_file2_enum_type field_n;
   ..
} some_complex_struct_t;