Стиль программирования на Си, описание функции Опции

[sKWO]

Добрый день!
Столкнулся со следующей проблемой.
нашол код как сделать восемь таймеров написанный Alechin Jan.
Первое что кидается в глаза та это синтаксис мне непонятный.
Вот к примеру прототип функции остановки тай мера:

Код

void Stop_Timer(IN IDX timer);

ну и сама функция:

Код

/*--------------------------------------------------------------------------------------------*/
/* Процедура остановки таймера.                                                               */
/* Принимает:   номер таймера (0 - 7).                                                        */
/* Возвращает:  ничего не возвращает.                                                         */
/*--------------------------------------------------------------------------------------------*/
__monitor void Stop_Timer(IN IDX timer)
{
  Timer[timer].Timer_Ena = TIMER_DIS;
  return;
}

Непонятно что такое IDX? Ну IN понятно, направление, очень удобно.
IDX по ходу здесь беззнаковый чар.
Ну и соответственно вопрос:
Этот синтаксис возможен через какоето макроопределение?
Может кто знает, подскажите, уверен это интерессно не только мне.
Вот ещё пример

Код

void Start_Timer(IN IDX timer, IN WORD interval, IN pTIMER_FUNC pFunc = NULL, IN bool cycle = TIMER_ONCE);

Спасибо.

[SasaVitebsk]

Вот об этом я и говорю - богатство выбора в рамках языка.

При написании сложных операторов с большим количеством операций по типу ++/-- могут быть грабли. Они достаточно подробно описаны даже в учебниках. Но, как мне кажется, не стоит перегружать операторы. Это неудобно для отладки к примеру и ухудшает читаемость. С другой стороны, совершенно очевидно, что компилятору по барабану написали ли вы формулу одним оператором или тремя. Качество сгенерированного кода не ухудшится

[zltigo]

... совершенно очевидно, что компилятору по барабану написали ли вы формулу одним оператором или тремя. Качество сгенерированного кода не ухудшится

Компиляторы умнеют, но тем не менее пока не умнее Вас и на подсказку вполне вероятно, ответят лучшим кодом.

Более того, при написании 3мя операторами оно может и существенно улучшиться
если знаешь как правильно разбить эти 3 оператора на нужное количество строк...

Вы знаете? Тогда пример в студию......

Поэтому, когда мне закинут в уши мысль типа...

ну зачем-же гордится своей наивностью?

[singlskv]

Вы знаете? Тогда пример в студию......

Да пожалуйста, WinAvr20060421, на IAR тоже как-то проверял, чуть получше но тоже не блеск:

Код

#include <avr/io.h>

volatile unsigned char al=0xFF;
volatile unsigned char ah=0xFF;
volatile unsigned char Pb,Pc,Pd;

int main()
{
  unsigned char pb,pc,pd;

  unsigned char tmpl = al;
  unsigned char tmph = ah;

//------------ Вариант N1 ("правильный")
  pb = (tmph & 0b10000000) | ((tmph & 0b01110000) >> 1) | ((tmph & 0b00001100) >> 2);
  pc = ((tmph & 0b00000011) << 2) | ((tmpl & 0b11000000) >> 6);
  pd = tmpl <<2;
//----- сохраняем результат
  Pb = pb;
  Pc = pc;
  Pd = pd;


  tmpl = al;
  tmph = ah;

//------------ Вариант N2 ("неправильный :) ")
  pd = (tmpl << 2);
  pc = tmph & 0b01111100;
  pc >>= 1;
  pb = (tmph & 0b10000000);
  pb |= (pc & 0b00111000);
  pc &= 0b00000110;
  pc >>= 1;
  pb |= pc;
  pc = (tmph&0b00000011);
  pc <<= 2;
  pd = tmpl >> 6;
  pc |= pd;
  pd = tmpl << 2;
//----- сохраняем результат
  Pb = pb;
  Pc = pc;
  Pd = pd;

//---------------------------

  while (1);

}

результат компиляции:

Код

pb = (tmph & 0b10000000) | ((tmph & 0b01110000) >> 1) | ((tmph & 0b00001100) >> 2);
  6c:    24 2f           mov    r18, r20
  6e:    33 27           eor    r19, r19
  70:    c9 01           movw    r24, r18
  72:    80 77           andi    r24, 0x70; 112
  74:    90 70           andi    r25, 0x00; 0
  76:    95 95           asr    r25
  78:    87 95           ror    r24
  7a:    40 78           andi    r20, 0x80; 128
  7c:    48 2b           or    r20, r24
  7e:    c9 01           movw    r24, r18
  80:    8c 70           andi    r24, 0x0C; 12
  82:    90 70           andi    r25, 0x00; 0
  84:    95 95           asr    r25
  86:    87 95           ror    r24
  88:    95 95           asr    r25
  8a:    87 95           ror    r24
  8c:    48 2b           or    r20, r24
  pc = ((tmph & 0b00000011) << 2) | ((tmpl & 0b11000000) >> 6);
  8e:    23 70           andi    r18, 0x03; 3
  90:    30 70           andi    r19, 0x00; 0
  92:    22 0f           add    r18, r18
  94:    33 1f           adc    r19, r19
  96:    22 0f           add    r18, r18
  98:    33 1f           adc    r19, r19
  9a:    85 2f           mov    r24, r21
  9c:    99 27           eor    r25, r25
  9e:    36 e0           ldi    r19, 0x06; 6
  a0:    96 95           lsr    r25
  a2:    87 95           ror    r24
  a4:    3a 95           dec    r19
  a6:    e1 f7           brne    .-8      ; 0xa0 <main+0x44>
  a8:    28 2b           or    r18, r24
  pd = tmpl <<2;
  aa:    55 0f           add    r21, r21
  ac:    55 0f           add    r21, r21

Код

  pd = (tmpl << 2);
  pc = tmph & 0b01111100;
  c2:    24 2f           mov    r18, r20
  c4:    2c 77           andi    r18, 0x7C; 124
  pc >>= 1;
  c6:    26 95           lsr    r18
  pb = (tmph & 0b10000000);
  c8:    94 2f           mov    r25, r20
  ca:    90 78           andi    r25, 0x80; 128
  pb |= (pc & 0b00111000);
  cc:    82 2f           mov    r24, r18
  ce:    88 73           andi    r24, 0x38; 56
  d0:    98 2b           or    r25, r24
  pc &= 0b00000110;
  d2:    26 70           andi    r18, 0x06; 6
  pc >>= 1;
  d4:    26 95           lsr    r18
  pb |= pc;
  d6:    92 2b           or    r25, r18
  pc = (tmph&0b00000011);
  d8:    24 2f           mov    r18, r20
  da:    23 70           andi    r18, 0x03; 3
  pc <<= 2;
  dc:    22 0f           add    r18, r18
  de:    22 0f           add    r18, r18
  pd = tmpl >> 6;
  e0:    85 2f           mov    r24, r21
  e2:    82 95           swap    r24
  e4:    86 95           lsr    r24
  e6:    86 95           lsr    r24
  e8:    83 70           andi    r24, 0x03; 3
  pc |= pd;
  ea:    28 2b           or    r18, r24
  pd = tmpl << 2;
  ec:    55 0f           add    r21, r21
  ee:    55 0f           add    r21, r21

ИТОГО:
"Правильный" 21 слов 58 тактов
"Неправильный" 17 слов 23 такта

Выводы делаем сами

[zltigo]

Да пожалуйста, WinAvr20060421, на IAR тоже как-то проверял, чуть получше но тоже не блеск:

Ну и где обещанная экономия от

...правильно разбить эти 3 оператора на нужное количество строк...

Налицо ДВА РАЗНЫХ АЛГОРИТМА, а не описание одного и того-же "разным количеством строк".
Кроме того, посмею предположить, что под нормально оптимизирующим компилятором разница будет в пару команд максимум.

Выводы делаем сами

Сделал

Мне нравится стиль Microsoft, лучше трудно придумать.

Трудно придумать стиль в котором больше жертв принесено стилю ради собственно абсолютно формального стиля.

[singlskv]

Налицо ДВА РАЗНЫХ АЛГОРИТМА,

с ОДИНАКОВЫМ результатом, и принципиально не различающимся методом вычислений,
+ если Вы не обратили внимание, во втором варианте операции на одну больше

Кроме того, посмею предположить, что под нормально оптимизирующим компилятором разница будет в пару команд максимум.

покажите результат компиляции...

[ReAl]

с ОДИНАКОВЫМ результатом, и принципиально не различающимся методом вычислений,

Но тем не менее разных алгоритма :-)
Кстати, если переписать это так, как привычно мне - сначала сдвиги, потом маскирования (так как сдвиги С часто компилируются в ассемблерные сдвиги с последующим маскированием, маскирования, разделённые сдвигом, часто остаются, хотя они и ихбыточные, а вот два маскирования подряд компиляторы как правило объединяют ), да и мне лично проще анализировать "сначала сдвиг, потом маскирование"

Код

__asm__ volatile ("nop" ::); // так удобнее искать потом границы фрагментов

  tmpl = al;
  tmph = ah;

  pb = (tmph & 0b10000000) | ((tmph >> 1) & 0b00111000) | ((tmph >> 2) & 0b00000011);
  pc = ((tmph << 2) & 0b00001100) | ((tmpl >> 6) & 0b00000011);
  pd = tmpl <<2;
//-----
  Pb = pb;
  Pc = pc;
  Pd = pd;
__asm__ volatile ("nop" ::);

то особой разницы-то и под gcc не видно...

Код

/* #APP */
    nop
/* #NOAPP */
    lds r19,al
    lds r25,ah
    mov r18,r25
    lsr r18
    andi r18,lo8(56)
    mov r24,r25
    lsr r24
    lsr r24
    andi r24,lo8(3)
    or r18,r24
    mov r24,r25
    andi r24,lo8(-128)
    or r18,r24
    lsl r25
    lsl r25
    andi r25,lo8(12)
    mov r24,r19
    swap r24
    lsr r24
    lsr r24
    andi r24,lo8(3)
    or r25,r24
    lsl r19
    lsl r19
    sts Pb,r18
    sts Pc,r25
    sts Pd,r19
/* #APP */
    nop
/* #NOAPP */
    lds r20,al
    lds r25,ah
    mov r24,r25
    andi r24,lo8(124)
    lsr r24
    mov r19,r24
    andi r19,lo8(56)
    mov r18,r25
    andi r18,lo8(-128)
    or r19,r18
    andi r24,lo8(6)
    lsr r24
    or r19,r24
    andi r25,lo8(3)
    lsl r25
    lsl r25
    mov r24,r20
    swap r24
    lsr r24
    lsr r24
    andi r24,lo8(3)
    or r25,r24
    sts Pb,r19
    sts Pc,r25
    lsl r20
    lsl r20
    sts Pd,r20
.L2:
    rjmp .L2

Трудно придумать стиль в котором больше жертв принесено стилю ради собственно абсолютно формального стиля.

+1
У меня мозги в трубочку сворачиваются и через уши вылазят, когда я вижу идентификаторы в стиле
ВЗБЗД взбздНуть;
Их трудно произнести и, как следствие, ими трудно мыслить. Зато вылет за правый край экрана даже при отступах по 2 символа (о ужас дельфийский) гарантирован даже на операторах средней сложности.
Итого народ пишет исключительно простые, но софт от этого ни компактнее, ни лучше не становится. Как, впрочем, не становится лучше и обычный текст, не содержащий совершенно сложноподчинённых предложений, а состоящий из одних простых ("зато нет глюкодрома с запятыми" ).