- 1
- 2
- 3
- 4
- 5
- 6
- 7
static inline int int_cmp(const void *a, const void *b) {
const ut64 va = *(const ut64 *)a;
const ut64 vb = *(const ut64 *)b;
if (va > vb) return 1;
if (va < vb) return -1;
return 0;
}
Нашли или выдавили из себя код, который нельзя назвать нормальным, на который без улыбки не взглянешь? Не торопитесь его удалять или рефакторить, — запостите его на говнокод.ру, посмеёмся вместе!
Всего: 332
−47
static inline int int_cmp(const void *a, const void *b) {
const ut64 va = *(const ut64 *)a;
const ut64 vb = *(const ut64 *)b;
if (va > vb) return 1;
if (va < vb) return -1;
return 0;
}
−48
// https://github.com/vk-com/kphp-kdb/blob/ce1ac4fbde2d3b546936ad07d6a748958f6d2198/net/net-http-server.c#L253
if (D->wlen == 3 && !memcmp (D->word, "GET", 3)) {
D->query_type = htqt_get;
} else if (D->wlen == 4) {
if (!memcmp (D->word, "HEAD", 4)) {
D->query_type = htqt_head;
} else if (!memcmp (D->word, "POST", 4)) {
D->query_type = htqt_post;
}
}
//...
if (D->wlen != 0) {
/* HTTP/x.y */
if (D->wlen != 8) {
c->parse_state = htqp_skiptoeoln;
D->query_flags |= QF_ERROR;
} else {
if (!memcmp (D->word, "HTTP/1.0", 8)) {
D->http_ver = HTTP_V10;
} else if (!memcmp (D->word, "HTTP/1.1", 8)) {
D->http_ver = HTTP_V11;
} else {
c->parse_state = htqp_skiptoeoln;
D->query_flags |= QF_ERROR;
}
}
}
...
if (D->wlen == 4 && !strncasecmp (D->word, "host", 4)) {
D->query_flags |= QF_HOST;
} else if (D->wlen == 10 && !strncasecmp (D->word, "connection", 10)) {
D->query_flags |= QF_CONNECTION;
} else if (D->wlen == 14 && !strncasecmp (D->word, "content-length", 14)) {
D->query_flags |= QF_DATASIZE;
} else {
D->query_flags &= ~(QF_HOST | QF_DATASIZE | QF_CONNECTION);
}
//...
Великие олимпиадники-оптимизаторы, разработчики kPHP. Лучше сначала проверить длину строки, и только потом, если длина строки подходящая, проверять строку через strncasecmp (очень дорогостоящая операция)
Об их мегагениальных оптимзациях я уже ранее писал: http://govnokod.ru/15406
Но тут наверняка ж можно намного лучше заоптимизировать. Давайте подумаем, как можно улучшить сие творение истинных гениев
−47
printf(fmt,x1,x2,x3,x4,x5,x6,x7,x8,x9)
char fmt[];
{
extern printn, putchar;
char s[];
auto adx[], x, c;
adx = &x1; /* argument pointer */
loop:
while((c = *fmt++) != '%') {
if(c == '\0')
return;
putchar(c);
}
x = *adx++;
switch (c = *fmt++) {
case 'd': /* decimal */
case 'o': /* octal */
if(x < 0) {
x = -x;
if(x<0) { /* is - infinity */
if(c=='o')
printf("100000");
else
printf("-32768");
goto loop;
}
putchar('-');
}
printn(x, c=='o'?8:10);
goto loop;
case 'c': /* char */
putchar(x);
goto loop;
case 's': /* string */
s = x;
while(c = *s++)
putchar(c);
goto loop;
}
putchar('%');
fmt--;
adx--;
goto loop;
}
from http://minnie.tuhs.org/cgi-bin/utree.pl?file=V2/lib/printf.c
−1
(* basic power axiom
safe_comp_power x y =
case
(x = 0) and (y <> 0) -> 1
(x = 1) -> x
((x <> 0) and (y >= 0)) or ((x = 0) and (y > 0)) -> x * (safe_comp_power x (y - 1))
*)
logic safe_comp_pow : int, int -> int
axiom safe_comp_pow_int_A_1 : forall x : int. (x <> 0) -> safe_comp_pow(x, 0) = 1
axiom safe_comp_pow_int_A_2 : forall x : int. safe_comp_pow(x, 1) = x
axiom safe_comp_pow_int_A_3 : forall x,y : int. ((x <> 0) and (y >= 0)) or ((x = 0) and (y > 0)) -> safe_comp_pow(x, y) = x*(safe_comp_pow(x,y-1))
goal g_1 :
forall a,n : int.
a <> 0 -> n >= 0 ->
safe_comp_pow(a,n+1) = safe_comp_pow(a,n)*a
Язык для SMT солвера alt-ergo https://alt-ergo.ocamlpro.com/try.php . Аксиомы для возведения в степень. Возводить в отрицательную степень нельзя. Ноль в степени ноль - нельзя. Логика первого порядка. Должна быть справедлива для целых. Правда в одной аксиоме я допустил баг. Я его уже нашел. Можете тоже попробовать найти его
−48
uint8_t n1[][2] = {{1,2}, {3,4}, {5,6}, {99,88}};
uint8_t n2[][2] = {{7,8}, {9,10}, {11,12}, {99,88}};
uint8_t n3[][2] = {{13,14}, {15,16}, {17,18}, {99,88}};
// Надо сделать массив из указателей на двумерные массивы
uint8_t (*ars[3])[2] = { n1, n2, n3}; // полная херня, нечитаемо
typeof( typeof(uint8_t [2]) *) ars2[3] = {n1, n2, n3}; // можно так
typeof( typeof(uint8_t [2]) *[3]) ars3 = {n1, n2, n3}; // можно еще так
typeof(uint8_t (*)[2]) ars4[3] = {n1, n2, n3}; // во, теперь заебись!
Почему в Си так по-дебильному надо объявлять всякие массивы указателей на двумерные массивы и тому подобную херню? Через typeof получается куда понятней
−48
/*
* mfi_tbolt_adp_reset - For controller reset
* @regs: MFI register set
*/
int
mfi_tbolt_adp_reset(struct mfi_softc *sc)
{
int retry = 0, i = 0;
int HostDiag;
MFI_WRITE4(sc, MFI_WSR, 0xF);
MFI_WRITE4(sc, MFI_WSR, 4);
MFI_WRITE4(sc, MFI_WSR, 0xB);
MFI_WRITE4(sc, MFI_WSR, 2);
MFI_WRITE4(sc, MFI_WSR, 7);
MFI_WRITE4(sc, MFI_WSR, 0xD);
for (i = 0; i < 10000; i++) ;
HostDiag = (uint32_t)MFI_READ4(sc, MFI_HDR);
while (!( HostDiag & DIAG_WRITE_ENABLE)) {
for (i = 0; i < 1000; i++);
HostDiag = (uint32_t)MFI_READ4(sc, MFI_HDR);
device_printf(sc->mfi_dev, "ADP_RESET_TBOLT: retry time=%x, "
"hostdiag=%x\n", retry, HostDiag);
if (retry++ >= 100)
return 1;
}
device_printf(sc->mfi_dev, "ADP_RESET_TBOLT: HostDiag=%x\n", HostDiag);
MFI_WRITE4(sc, MFI_HDR, (HostDiag | DIAG_RESET_ADAPTER));
for (i=0; i < 10; i++) {
for (i = 0; i < 10000; i++); // <--- двойной говнокод.
}
HostDiag = (uint32_t)MFI_READ4(sc, MFI_RSR);
while (HostDiag & DIAG_RESET_ADAPTER) {
for (i = 0; i < 1000; i++) ;
HostDiag = (uint32_t)MFI_READ4(sc, MFI_RSR);
device_printf(sc->mfi_dev, "ADP_RESET_TBOLT: retry time=%x, "
"hostdiag=%x\n", retry, HostDiag);
if (retry++ >= 1000)
return 1;
}
return 0;
}
https://svnweb.freebsd.org/base/head/sys/dev/mfi/mfi_tbolt.c?view=markup&pathrev=235016#l 145
Двойной говнокод. Мало того, что такие задержки на циклах попросту бесполезны, любой нормальный компилятор их выбросит при оптимизации, так там еще и ошибка с переиспользованием переменной i из внешнего цикла во внутреннем
−43
#include <inttypes.h>
uint64_t pow_(uint64_t num, uint8_t pow)
{
static const void *array_pow[] = { &&l0, &&l1, &&l2, &&l3, &&l4, &&l5, &&l6,/* ....*/ };
uint64_t ret = 1;
goto *array_pow[pow];
/* ... */
l6: ret *=num;
l5: ret *=num;
l4: ret *=num;
l3: ret *=num;
l2: ret *=num;
l1: ret *=num;
l0:
return ret;
}
Царский анролл возведения в степень через gcc-шные goto. Сам придумал. Но тут еще вот какая западня. Оптимизируется он хреново. Например, если взять возведение в степень 6 http://goo.gl/6SK2et
то можно обойтись 3 инструкциями imul в то время как в хрени с метками их целых 6.
+76
.global shit
.type shit, @function
shit:
/* prologue: function */
/* frame size = 0 */
/* stack size = 0 */
.L__stack_usage = 0
mov r30,r24
mov r31,r25
ldd r18,Z+1
ldd r22,Z+2
mov r24,r22
ldi r25,0
ldi r26,0
ldi r27,0
mov r26,r24
mov r27,r25
clr r25
clr r24
or r25,r18
ld r18,Z
or r24,r18
ldd r18,Z+3
mov r22,r24
mov r23,r25
mov r24,r26
mov r25,r27
or r25,r18
ret
.size shit, .-shit
Вот такое ГЛОБАЛЬНОЕ ГОВНО мне делает GCC под AVR
Код разворота байтиков:
unsigned long int shit(unsigned char *a)
{
return
( unsigned long int)a[0] << 0 |
((unsigned long int)a[1] << 8 ) |
((unsigned long int)a[2] << 16) |
((unsigned long int)a[3] << 24);
}
#if defined (L_bswapsi2)
;; swap bytes
;; r25:r22 = bswap32 (r25:r22)
DEFUN __bswapsi2
bswap r22, r25
bswap r23, r24
ret
ENDF __bswapsi2
#endif /* defined (L_bswapsi2) */
−50
#define OP(a,b,op) ((a)op(b))
#define MKFUNC_a_op_b(type, opname, op) void type##_##opname##_##type(const void *a, const void *b, void *out) \
{\
type tmp = OP(*(type*)a,*(type*)b,op);\
memcpy(out,(void*)(&tmp),sizeof(type));\
}
#define MKALLF_int(type) \
MKFUNC_a_op_b(type,plus,+) MKFUNC_a_op_b(type,minus,-) \
MKFUNC_a_op_b(type,div,/) MKFUNC_a_op_b(type,mod,%) \
MKFUNC_a_op_b(type,and,&) MKFUNC_a_op_b(type,or,|) \
MKFUNC_a_op_b(type,xor,^)
MKALLF_int(int8_t)
MKALLF_int(uint8_t)
MKALLF_int(int16_t)
MKALLF_int(uint16_t)
MKALLF_int(int32_t)
MKALLF_int(uint32_t)
MKALLF_int(int64_t)
MKALLF_int(uint64_t)
#define MKFUNC_conv_t(type1, type2) void type1##_to_##type2(const void *a, void *out) \
{\
type2 tmp = (type2)(*(type1*)a);\
memcpy(out,(void*)(&tmp),sizeof(type2));\
}
#define MKFUNC_con_M(type) \
MKFUNC_conv_t(type, int8_t) \
MKFUNC_conv_t(type, uint8_t) \
MKFUNC_conv_t(type, int16_t) \
MKFUNC_conv_t(type, uint16_t) \
MKFUNC_conv_t(type, int32_t) \
MKFUNC_conv_t(type, uint32_t) \
MKFUNC_conv_t(type, int64_t) \
MKFUNC_conv_t(type, uint64_t)
MKFUNC_con_M(int8_t)
MKFUNC_con_M(uint8_t)
MKFUNC_con_M(int16_t)
MKFUNC_con_M(uint16_t)
MKFUNC_con_M(int32_t)
MKFUNC_con_M(uint32_t)
MKFUNC_con_M(int64_t)
MKFUNC_con_M(uint64_t)
Это я типа такую заготовку для стековой ВМ делаю, определяю операции(инструкции) для опкодов кагбэ. Потом у меня там будет массив указателей на функции, ну и я их буду вызывать, пропихивая аргументы. Но похоже что сишный препроцессор это говно полное, и надо кодогеренератор для набора такой ерунды делать.
−47
#include <stdio.h>
#include <inttypes.h>
typedef struct {uint32_t dummy;} str32;
int main (void)
{
// тут получаются нули
printf("%zu\n", sizeof( struct {uint32_t;} ) );
printf("%zu\n", sizeof( (struct {uint32_t;}){} ) );
// а тут получаются 4 как и планировалось
printf("%zu\n", sizeof( str32 ) );
printf("%zu\n", sizeof(uint32_t) );
return 0;
}
Попытки получить размер анонимной структуры. Компиляторы clang gcc icc под линупсом почему-то возвращают 0. Не может же это быть багом сразу в трех компиляторах?