Няшная – Страница 10

Няшная / Говнокод #27880

0

1
2
3
4
5
6
7
8
9
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
95
96
97
98
99
100

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

struct two_val
{
  const int32_t a[2];
};

struct two_val_and_status
{
  const bool is_swap;
  const struct two_val t_v;
};

struct array
{
  const int32_t a[10];
};

struct array_and_status
{
  const bool is_swap;
  const size_t pos;
  const struct array arr;
};

// Эта суперфункцональная функция сортировки двух элементов не просто сортирует два элемента
// но и еще сообщает о том, нужно ли было для этого обменивать два значения
struct two_val_and_status sort2(const struct two_val a)
{
  return (a.a[0] > a.a[1]) ? (struct two_val_and_status){true, {{a.a[1], a.a[0]}}} : (struct two_val_and_status){false, a};
}

struct two_val read_two_val(const struct array arr, const size_t pos)
{
  return (struct two_val){{arr.a[pos], arr.a[pos+1]}};
}

struct array store_val(const struct array arr, const int32_t val, size_t pos)
{
  return (struct array) // Царский анролл
  {{
    pos != 0 ? arr.a[0] : val,
    pos != 1 ? arr.a[1] : val,
    pos != 2 ? arr.a[2] : val,
    pos != 3 ? arr.a[3] : val,
    pos != 4 ? arr.a[4] : val,
    pos != 5 ? arr.a[5] : val,
    pos != 6 ? arr.a[6] : val,
    pos != 7 ? arr.a[7] : val,
    pos != 8 ? arr.a[8] : val,
    pos != 9 ? arr.a[9] : val
  }};
}

struct array store_two_val(const struct array arr, const struct two_val val, const size_t pos)
{
  return store_val(store_val(arr,val.a[0],pos),val.a[1],pos+1);
}

// суперохуительная рекурсивная функция сортировки пузырьком
struct array_and_status bubble_sort_rec(struct array_and_status state) 
{
  if (state.pos == 9)
  {
    if (state.is_swap == false) // Ура! Сортировка пузырьком завершена!
    {
      return state;
    }
    else
    { // а иначе нам надо по-новой сортировать!
      return bubble_sort_rec((struct array_and_status){.is_swap = false, .pos=0, .arr = state.arr});
    }
  }
  else
  {
    const struct two_val_and_status tmp = sort2(read_two_val(state.arr, state.pos));
    return bubble_sort_rec(
      (struct array_and_status)
      {
        .is_swap = tmp.is_swap || state.is_swap,
        .pos=state.pos+1,
        .arr = store_two_val(state.arr, tmp.t_v, state.pos)
      }
    );
  }
}

int main(void)
{
  const struct array_and_status a = {.is_swap = false, .pos = 0, .arr = {{8,2,4,1,3,5,7,0,6,9}} };
  const struct array_and_status a_sort = bubble_sort_rec(a);
  for(size_t i = 0; i < 10; i++) // ох уж это убогое императивное программирование!!!
  {
    printf("%" PRIu32 ", ", a_sort.arr.a[i]);
  }
  return EXIT_SUCCESS;
}

Функциональная сортировка пузырьком
https://wandbox.org/permlink/dGyvo82lgQGInD0Y

j123123, 19.12.2021 (Updated 19.12.2021)

Комментарии (108, +108)

Няшная / Говнокод #27873

0

1
2
3
4
5
6
7
8
9
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.12.2021 (Updated 13.12.2021)

Комментарии (35, +35)

Няшная / Говнокод #27859

0

1
2
3
4
5
6
7
8
9
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.12.2021 (Updated 06.12.2021)

Комментарии (24, +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.12.2021 (Updated 02.12.2021)

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

Няшная / Говнокод #27835

0

1
2
3
4
5
6
7
8
9
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.11.2021 (Updated 22.11.2021)

Комментарии (200, +200)

Няшная / Говнокод #27825

0

1
2
3
4
5
6
7
8
9
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.11.2021 (Updated 17.11.2021)

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

Няшная / Говнокод #27812

0

1
2
3
4
5
6
7
8
9
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.11.2021 (Updated 12.11.2021)

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

Няшная / Говнокод #27807

0

1
2
3
4
5
6
7
8
9
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.11.2021 (Updated 09.11.2021)

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

Няшная / Говнокод #27797

0

1
2
3
4
5
6
7
8
9
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.11.2021 (Updated 06.11.2021)

Комментарии (254, +254)

Няшная / Говнокод #27792

0

1
2
3
4
5
6
7
8
9
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.11.2021 (Updated 05.11.2021)

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