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

[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]

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

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

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

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

[zltigo]

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

А самому? Думаете поленюсь copy-paste и убрать отрыжки древних ассемблеров не имеющих препроцессоров? Ладно:

Код

//   19 void m1(void)
m1:
//   20 {
//   21 unsigned char pb,pc,pd;
//   22
//   23 unsigned char tmpl = al;
        LDI     R30, LOW(al)
        LDI     R31, (al) >> 8
        LD      R19, Z
//   24 unsigned char tmph = ah;
        LDD     R16, Z+1
//   25
//   26 //------------ Вариант N1 ("правильный")
//   27   pb = ( tmph & 0x80 )|( (tmph & 0x70) >> 1 )|( (tmph & 0xC0) >> 2 );
//   28   pc = ((tmph & 0x03) << 2 )|( (tmpl & 0xC0) >> 6 );
//   29   pd = tmpl <<2;
//   30
//   31 //----- сохраняем результат
//   32   Pb = pb;
        MOV     R18, R16
        ANDI    R18, 0x80
        MOV     R17, R16
        ANDI    R17, 0x70
        ASR     R17
        OR      R18, R17
        MOV     R17, R16
        ANDI    R17, 0xC0
        LSR     R17
        LSR     R17
        OR      R18, R17
        STD     Z+2, R18
//   33   Pc = pc;
        ANDI    R16, 0x03
        LSL     R16
        LSL     R16
        LDI     R17, 4
        MUL     R19, R17
        OR      R16, R1
        STD     Z+3, R16
//   34   Pd = pd;
        LSL     R19
        LSL     R19
        STD     Z+4, R19
//   35
//   36 }
        RET



//   38 void m2(void)
m2:
//   39 {
//   40
//   41 unsigned char pb,pc,pd;
//   42
//   43 unsigned char tmpl = al;
        LDI     R30, LOW(al)
        LDI     R31, (al) >> 8
        LD      R20, Z
//   44 unsigned char tmph = ah;
        LDD     R18, Z+1
//   45
//   46 //------------ Вариант N2 ("неправильный :) ")
//   47       pd = (tmpl << 2);
//   48
//   49     pc = tmph & 0x7C;
//   50       pc >>= 1;
        MOV     R17, R18
        ANDI    R17, 0x7C
        LSR     R17
//   51
//   52     pb = (tmph & 0x80);
//   53       pb |= (pc & 0x38);
//   54       pc &= 0x06;
//   55       pc >>= 1;
//   56       pb |= pc;
//   57       pc = tmph & 0x03;
//   58       pc <<= 2;
//   59       pd = tmpl >> 6;
//   60       pc |= pd;
//   61       pd = tmpl << 2;
//   62 //----- сохраняем результат
//   63   Pb = pb;
        MOV     R19, R18
        ANDI    R19, 0x80
        MOV     R16, R17
        ANDI    R16, 0x38
        OR      R19, R16
        ANDI    R17, 0x06
        LSR     R17
        OR      R19, R17
        STD     Z+2, R19
//   64   Pc = pc;
        ANDI    R18, 0x03
        LSL     R18
        LSL     R18
        LDI     R16, 4
        MUL     R20, R16
        OR      R18, R1
        STD     Z+3, R18
//   65   Pd = pd;
        LSL     R20
        LSL     R20
        STD     Z+4, R20
//   66 }
        RET

P.S.
Получилось, что все ухищрения яйца выеденного не стоят....

[singlskv]

и убрать отрыжки древних ассемблеров не имеющих препроцессоров?

это не отрыжки, это удобство для данной конкретной задачки,
по битикам видно что куда попадает, но это просто специфика...
Кстати Вы вот так и ошиблись при переводе из двоичного представления в 16x
вот так:
(tmph & 0b10000000)......(tmph & 0b01110000).......(tmph & 0b00001100 )
сразу же видно что взяли нужные битики,
а вот так нифига не видно:
( tmph & 0x80 )........(tmph & 0x70)..........(tmph & 0xC0 )

А самому?

Код

........

Я же говорю, пробовал, раньше код был намного хуже.
Какая версия ?
С таким выходом - убедили!

[zltigo]

это не отрыжки, это удобство для данной конкретной задачки,
по битикам видно что куда попадает, но это просто специфика...

Да ничего не видно, при "видно" не ошибся-бы,даже в 2 часа ночи...
А тут даже на 8bit глазоломка, а уж на 32

сразу же видно что взяли нужные битики,

Более-менее видно когда такое написано,хоть на ASM, хоть на C, как минимум так:

Код

( tmph & BIT7 )........(tmph & (BIT6|BIT5|BIT4))..........

а вобще надо давать осмысленные имена

Код

( tmph & B_SIGN )........(tmph & M_LEVEL)..........

Я же говорю, пробовал, раньше код был намного хуже.
Какая версия ?

IAR 5.10, но, полагаю, и на 4.x будет тот-же результат.