Си — Говнокод.ру

Си / Говнокод #27873

0

01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68

#include <stdio.h>
#include <stdlib.h>
#include <inttypes.h>

typedef struct
{
  int32_t x;
  int32_t y;
} coord;

coord stack[1000000] = {{0,0}};

size_t stack_end = 1;

int checkstack(coord in)
{
  for(size_t i = 0; i < stack_end; i++)
  {
    if((stack[i].x == in.x) && (stack[i].y == in.y)) 
    {
      return 0;
    }
  }
  stack[stack_end] = in;
  stack_end += 1;
  return 1;
}

void consume_char(char ch, coord *c, uint32_t *sum)
{
  switch( ch )
  {
    case '>':
      c->x += 1;
      break;
    case '<':
      c->x -= 1;
      break;
    case '^':
      c->y += 1;
      break;
    case 'v':
      c->y -= 1;
      break;
    default:
      printf("ERROR!!");
      exit(-1);
  }
  *sum += checkstack(*c);
}

const char *arr = "^><^>>>^<^v<v^^vv^><<^.....";


int main(void)
{
  const char *arr_ptr = arr;
  coord crd = {0,0};
  uint32_t sum = 1;
  while (*arr_ptr != '\0')
  {
    //printf("test\n");
    consume_char(*arr_ptr, &crd, &sum);
    arr_ptr++;
  }
  printf("%" PRIu32 "\n", sum);
  return EXIT_SUCCESS;
}

Решил от нехуй делать попроходить https://adventofcode.com/
Вот например https://adventofcode.com/2015/day/3

j123123, 13 Декабря 2021

Комментарии (34)

Си / Говнокод #27859

+1

01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18

#include <conio.h>

void activateAlarm(int channelID) {

    int key = 0;

    while(temperatureChannel[channelID].currentTemperature > temperatureChannel[channelID].highLimit
        ||temperatureChannel[channelID].currentTemperature < temperatureChannel[channelID].lowLimit) {

        beep(350,100);

        if (_kbhit()) {
            key = _getch();
            if(key == 'P');
                break;
        }    
    }
}

3_dar, 06 Декабря 2021

Комментарии (24)

Си / Говнокод #27850

0

1
2
3
4
5

#define POOL_ZERO_DOWN_LEVEL_SUPPORT
#include <wdm.h>

char* p = ExAllocatePoolZero(NonPagedPool, 42, '_GK_');
ASSERT(p[0] == 0);

https://www.osr.com/blog/2020/07/14/bug-in-new-function-exallocatepoolzero-results-in-security-vulnerability-and-crashes/

microsoft_real_calloc() и 100500 способов отстрела ноги с помощью него.

bormand, 02 Декабря 2021

Комментарии (229)

Си / Говнокод #27835

0

01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

// https://github.com/microsoft/Windows-driver-samples/blob/d3ec258921cfcef7b053b5a2c866330d43dd3f03/filesys/fastfat/dumpsup.c#L35

#define DumpLabel(Label,Width) {                                          \
    size_t i, LastPeriod=0;                                                \
    CHAR _Str[20];                                                        \
    for(i=0;i<2;i++) { _Str[i] = UCHAR_SP;}                               \
    for(i=0;i<strlen(#Label);i++) {if (#Label[i] == '.') LastPeriod = i;} \
    strncpy(&_Str[2],&#Label[LastPeriod],Width);                          \
    for(i=strlen(_Str);i<Width;i++) {_Str[i] = UCHAR_SP;}                 \
    _Str[Width] = '\0';                                                   \
    DbgPrint("%s", _Str);                                                  \
}

#define DumpField(Field) {                                         \
    if ((FatDumpCurrentColumn + 18 + 9 + 9) > 80) {DumpNewLine();} \
    FatDumpCurrentColumn += 18 + 9 + 9;                            \
    DumpLabel(Field,18);                                           \
    DbgPrint(":%p", Ptr->Field);                                  \
    DbgPrint("         ");                                          \
}

#define DumpListEntry(Links) {                                     \
    if ((FatDumpCurrentColumn + 18 + 9 + 9) > 80) {DumpNewLine();} \
    FatDumpCurrentColumn += 18 + 9 + 9;                            \
    DumpLabel(Links,18);                                           \
    DbgPrint(":%p", Ptr->Links.Flink);                            \
    DbgPrint(":%p", Ptr->Links.Blink);                            \
}

#define DumpName(Field,Width) {                                    \
    ULONG i;                                                       \
    CHAR _String[256];                                             \
    if ((FatDumpCurrentColumn + 18 + Width) > 80) {DumpNewLine();} \
    FatDumpCurrentColumn += 18 + Width;                            \
    DumpLabel(Field,18);                                           \
    for(i=0;i<Width;i++) {_String[i] = (CHAR)Ptr->Field[i];}             \
    _String[Width] = '\0';                                         \
    DbgPrint("%s", _String);                                        \
}

#define TestForNull(Name) {                                 \
    if (Ptr == NULL) {                                      \
        DbgPrint("%s - Cannot dump a NULL pointer\n", Name); \
        return;                                             \
    }                                                       \
}

Макроговно от мекомягких для отладки файловой системы FAT

j123123, 22 Ноября 2021

Комментарии (198)

Си / Говнокод #27825

+2

01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81

#include <stdio.h>
#include <stdlib.h>
#include <inttypes.h>
#include <limits.h>
typedef unsigned __int128 uint128_t;
typedef __int128 int128_t;

// в чем тут по-вашему баг ?
uint64_t add1bit_left_1_bug(const uint64_t a, int shift)
{
  return ~(~(a << shift) >> shift);
}

uint64_t add1bit_left_1(const uint64_t a, int shift)
{
  return ~((uint128_t)~(uint64_t)((uint128_t)a << shift) >> shift);
}

// или тут ?
uint64_t add1bit_left_2_bug(const uint64_t a, int shift)
{
  return a | (uint64_t)(UINT64_MAX << (CHAR_BIT * sizeof(uint64_t) - shift));
}

uint64_t add1bit_left_2(const uint64_t a, int shift)
{
  return a | (uint64_t)((uint128_t)-1 << (CHAR_BIT * sizeof(uint64_t) - shift));
}

uint64_t add1bit_left_3(const uint64_t a, int shift)
{
  if (shift == 0) return a;
  return (uint64_t)((int64_t)((a << (shift-1)) | ((uint64_t)1 << (CHAR_BIT * sizeof(uint64_t) - 1)) ) >> (shift-1)); // а тут вообще UB
}


int main(void)
{
  // tests
  for (int i = 0; i <= 64; i++) // пробуем сдвигать от 0 до 64 включительно.
  {
    // for (uint128_t j = 0; j < UINT64_MAX+1; j++) - какая формальная верификация )))
    for (uint64_t j = 0; j < 100; j++)
    {
      if (add1bit_left_1(j,i) != add1bit_left_2(j,i))
      {
        printf("error1\n");
        printf("%" PRIu64 " %d\n", j,i);
        return EXIT_FAILURE;
      }
      if (add1bit_left_1(j,i) != add1bit_left_3(j,i))
        printf("error2\n");
      if (add1bit_left_2(j,i) != add1bit_left_3(j,i))
        printf("error3\n");
    }
  }
  printf("%" PRIX64 "\n", add1bit_left_1(0,0));
  printf("%" PRIX64 "\n", add1bit_left_2(0,0));
  printf("%" PRIX64 "\n", add1bit_left_3(0,0));
  printf("%" PRIX64 " - bug\n", add1bit_left_1_bug(0,0));
  printf("%" PRIX64 " - bug\n", add1bit_left_2_bug(0,0));
  puts("");
  printf("%" PRIX64 "\n", add1bit_left_1(0,1));
  printf("%" PRIX64 "\n", add1bit_left_2(0,1));
  printf("%" PRIX64 "\n", add1bit_left_3(0,1));
  printf("%" PRIX64 " - bug\n", add1bit_left_1_bug(0,1));
  printf("%" PRIX64 " - bug\n", add1bit_left_2_bug(0,1));
  puts("");
  printf("%" PRIX64 "\n", add1bit_left_1(0,2));
  printf("%" PRIX64 "\n", add1bit_left_2(0,2));
  printf("%" PRIX64 "\n", add1bit_left_3(0,2));
  printf("%" PRIX64 " - bug\n", add1bit_left_2_bug(0,2));
  printf("%" PRIX64 " - bug\n", add1bit_left_2_bug(0,2));
  puts("");
  printf("%" PRIX64 "\n", add1bit_left_1(0,64));
  printf("%" PRIX64 "\n", add1bit_left_2(0,64));
  printf("%" PRIX64 "\n", add1bit_left_3(0,64));
  printf("%" PRIX64 " - bug\n", add1bit_left_1_bug(0,64));
  printf("%" PRIX64 " - bug\n", add1bit_left_2_bug(0,64));
  return EXIT_SUCCESS;
}

Вореанты говнофункции, которая сдвигает влево uint64_t но набрасывает единички вместо ноликов.

j123123, 17 Ноября 2021

Комментарии (22)

Си / Говнокод #27812

+5

01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19

// http://cmustdie.com/ - баттхерт анскильных лалок, неосиливших сишку

// Возьмём следующий фрагмент кода на языке Си:

int x = 1;
x = x << sizeof(int) * 8;

// Попробуем предположить, какой результат у нас получится. Допустим, мы скомпилировали этот
// код для процессоров архитектуры ARM. Инструкция битового сдвига в рамках этой аппаратной
// платформы определена так, что итоговым значением переменной "x" должен быть "0". С другой
// стороны, мы можем транслировать нашу программу в машинный код архитектуры x86. И уже там 
// битовый сдвиг реализован таким образом, что значение "x" не изменится и останется равным
// "1". Мы могли бы сделать вывод, что результат работы данного фрагмента кода зависит от
// того, для какой аппаратной платформы мы его скомпилировали. Но на самом деле это не так.

// В действительности данный фрагмент кода может быть обработан компилятором любым возможным 
// и невозможным образом. Причина в следующем: согласно тексту стандарта языка Си битовый 
// сдвиг на величину, большую или равную размеру выражения в битах, является неопределённым
// поведением. Получается, нет никакой гарантии, что этот кусок кода вообще будет работать.

Охуеть конечно

j123123, 12 Ноября 2021

Комментарии (40)

Си / Говнокод #27807

+1

01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94

// https://github.com/j123123/sexpr_parse/blob/584fc23de71bebe02545214f819e16b720a2c1e2/my_struct_utils.c#L119

blob *
blob_scan_fromstream
(
  FILE *stream
)
{
  size_t st_len = 0;
  size_t st_alloc;
  uint8_t *st = NULL;

  while(true)
  {
    const int fg = getc(stream);
    if(fg == EOF)
    {
      PRV_ERR_MACRO();
    }
    uint8_t c = fg;
    if(!isprint(fg))
    {
      PRV_ERR_MACRO();
    }
    switch(c)
    {
      case '\\':
        {
          int c2 = getc(stream);
          switch(c2)
          {
            case 'x':
              {
                int c3[2] =
                {
                  getc(stream),
                  getc(stream)
                };
                uint8_t tmp[2];

                for(size_t i = 0; i < 2; ++i)
                {
                  switch(c3[i])
                  {
                    case '0' ... '9':
                      tmp[i] = c3[i]-'0';
                      break;
                    case 'a' ... 'f':
                      tmp[i] = c3[i]+10-'a';
                      break;
                    case 'A' ... 'F':
                      tmp[i] = c3[i]+10-'A';
                      break;
                    default:
                      PRV_ERR_MACRO();
                  }
                }
                M_PUSH(tmp[1] | tmp[0] << 4);
              }
              break;
            case '\\':
              M_PUSH('\\');
              break;
            case 't':
              M_PUSH('\t');
              break;
            case 'n':
              M_PUSH('\n');
              break;
            case '"':
              M_PUSH('"');
              break;
            default:
              PRV_ERR_MACRO();
          }
        }
        break;
//      case '\t':
//      case '\n':
//        PRV_ERR_MACRO();
//        break;
      case '"':
        goto end;
      default:
        M_PUSH(c);
    }
  }

end:
  ;
  blob *tmp = blob_init(st_len, st);
  PRV_FREE(st);
  return tmp;
}

Эта вот хрень вычитывает из "FILE *" одно "слово".

j123123, 09 Ноября 2021

Комментарии (97)

Си / Говнокод #27797

+1

01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

#include <stdio.h>

#define new(class) _##class##_##new
#define impl(class, method) _##class##_##method
struct Calculate
{
	int(*getOne)(struct Calculate*);
};

int impl(Calculate, getOne)(struct Calculate* this) { return 1; }
void* new(Calculate)(void)
{
	struct Calculate* class = malloc(sizeof(struct Calculate));
	class->getOne = impl(Calculate, getOne);
	return class;
}

struct CalculateProxy
{
	struct Calculate;
};

int impl(CalculateProxy, getOne)(struct Calculate* this)
{
	printf("Method call!\n");
	return impl(Calculate, getOne)(this);
}

void* new(CalculateProxy)(void)
{
	struct CalculateProxy* class = malloc(sizeof(struct CalculateProxy));
	class->getOne = impl(CalculateProxy, getOne);
	return class;
}

int main(void)
{
	struct Calculate* calc = new(CalculateProxy)();
	printf("%X!\n", calc->getOne(calc));
}

жавашок попросил реализовать паттерн прокси на Си

digitalEugene, 06 Ноября 2021

Комментарии (149)

Си / Говнокод #27792

0

01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

// https://github.com/dxFeed/dxfeed-c-api/blob/8f24055298c9751344db72da03ab8eb37dfeb6a5/src/DXAlgorithms.h#L63

#define CHECKED_CALL(func, param) \
	do { \
		if (!func(param)) { \
			return false; \
		} \
	} while (false)

#define CHECKED_CALL_0(func) \
	do { \
		if (!func()) { \
			return false; \
		} \
	} while (false)

#define CHECKED_CALL_1(func, param1) \
	do { \
		if (!func(param1)) { \
			return false; \
		} \
	} while (false)

#define CHECKED_CALL_2(func, param1, param2) \
	do { \
		if (!func(param1, param2)) { \
			return false; \
		} \
	} while (false)

#define CHECKED_CALL_3(func, param1, param2, param3) \
	do { \
		if (!func(param1, param2, param3)) { \
			return false; \
		} \
	} while (false)

#define CHECKED_CALL_4(func, param1, param2, param3, param4) \
	do { \
		if (!func(param1, param2, param3, param4)) { \
			return false; \
		} \
	} while (false)

#define CHECKED_CALL_5(func, param1, param2, param3, param4, param5) \
	do { \
		if (!func(param1, param2, param3, param4, param5)) { \
			return false; \
		} \
	} while (false)

Мокроебства

j123123, 05 Ноября 2021

Комментарии (11)

Си / Говнокод #27760

0

01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62

/* https://github.com/v7unix/v7unix/blob/ed636a47207476db76d53b7869447889dee3bbad/v7/usr/src/cmd/sh/mac.h */

#
/*
 *	UNIX shell
 *
 *	S. R. Bourne
 *	Bell Telephone Laboratories
 *
 */

#define LOCAL	static
#define PROC	extern
#define TYPE	typedef
#define STRUCT	TYPE struct
#define UNION	TYPE union
#define REG	register

#define IF	if(
#define THEN	){
#define ELSE	} else {
#define ELIF	} else if (
#define FI	;}

#define BEGIN	{
#define END	}
#define SWITCH	switch(
#define IN	){
#define ENDSW	}
#define FOR	for(
#define WHILE	while(
#define DO	){
#define OD	;}
#define REP	do{
#define PER	}while(
#define DONE	);
#define LOOP	for(;;){
#define POOL	}


#define SKIP	;
#define DIV	/
#define REM	%
#define NEQ	^
#define ANDF	&&
#define ORF	||

#define TRUE	(-1)
#define FALSE	0
#define LOBYTE	0377
#define STRIP	0177
#define QUOTE	0200

#define EOF	0
#define NL	'\n'
#define SP	' '
#define LQ	'`'
#define RQ	'\''
#define MINUS	'-'
#define COLON	':'

#define MAX(a,b)	((a)>(b)?(a):(b))

j123123, 20 Октября 2021

Комментарии (76)

Говнокод: по колено в коде.