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

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

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

// https://github.com/alpertron/calculators/blob/15607feafb0ddb1c075bb326dc6ea2224a4c50bb/siqs.c#L3720

            switch (NumberLengthA)
            {
            case 7:
              dRem = (double)*(piDividend + 6) * (double)rowPrimeTrialDivisionData->exp6 +
                (double)*(piDividend + 5) * (double)rowPrimeTrialDivisionData->exp5 +
                (double)*(piDividend + 4) * (double)rowPrimeTrialDivisionData->exp4 +
                (double)*(piDividend + 3) * (double)rowPrimeTrialDivisionData->exp3 +
                (double)*(piDividend + 2) * (double)rowPrimeTrialDivisionData->exp2 +
                (double)*(piDividend + 1) * (double)rowPrimeTrialDivisionData->exp1;
              break;
            case 6:
              dRem = (double)*(piDividend + 5) * (double)rowPrimeTrialDivisionData->exp5 +
                (double)*(piDividend + 4) * (double)rowPrimeTrialDivisionData->exp4 +
                (double)*(piDividend + 3) * (double)rowPrimeTrialDivisionData->exp3 +
                (double)*(piDividend + 2) * (double)rowPrimeTrialDivisionData->exp2 +
                (double)*(piDividend + 1) * (double)rowPrimeTrialDivisionData->exp1;
              break;
            case 5:
              dRem = (double)*(piDividend + 4) * (double)rowPrimeTrialDivisionData->exp4 +
                (double)*(piDividend + 3) * (double)rowPrimeTrialDivisionData->exp3 +
                (double)*(piDividend + 2) * (double)rowPrimeTrialDivisionData->exp2 +
                (double)*(piDividend + 1) * (double)rowPrimeTrialDivisionData->exp1;
              break;
            case 4:
              dRem = (double)*(piDividend + 3) * (double)rowPrimeTrialDivisionData->exp3 +
                (double)*(piDividend + 2) * (double)rowPrimeTrialDivisionData->exp2 +
                (double)*(piDividend + 1) * (double)rowPrimeTrialDivisionData->exp1;
              break;
            default:
              dRem = (double)*(piDividend + 2) * (double)rowPrimeTrialDivisionData->exp2 +
                (double)*(piDividend + 1) * (double)rowPrimeTrialDivisionData->exp1;
              break;
            }

Generic two integer variable equation solver
This calculator can solve equations of the form a⁢x² + b⁢x⁢y + c⁢y² + dx + ey + f = 0 where the unknowns x and y are integer numbers.

j123123, 22 Февраля 2019

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

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

0

01
02
03
04
05
06
07
08
09
10
11
12
13

// https://git.zx2c4.com/BruteZip/tree/read.c?id=e4e9c17b99e0d108136b8a07632b1ebaa7d09d28#n26

int main(int argc, char *argv[])
{
	union {
		long int l;
		char c[sizeof(long int)];
	} u;
	u.l = 1;
	if (u.c[sizeof(long int) - 1] == 1) {
		printf("This program only runs on little endian archs, because I'm lazy. Sorry.\n");
		return -2;
	}

Хуйня какая-то. Ведь sizeof(long int) может быть равен sizeof(char).

Но над такой питушней обычно никто не задумывается

j123123, 13 Февраля 2019

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

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

−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

// http://p99.gforge.inria.fr/p99-html/group__flexible.html

//C99 allows a flexible array member to be defined as the last member of a struct,
// namely an array of undetermined length.
//P99_DECLARE_STRUCT(package_head);

struct package_head {
  char name[20];
  size_t len;
  uint64_t data[];
};

// Such a struct can then be allocated on the heap with a suitable size such 
// that the field data has as many elements as fit in the allocated space from
// the start of data onward. Usually one would allocate such struct with

package_head *a = malloc(sizeof(package_head) + 10 * sizeof(uint64_t));
package_head *b = malloc(sizeof(*b) + 12 * sizeof(b->data[0]));

// This has several disadvantages. Firstly, the syntax is clumsy. We have to
// use a relatively complicated expression that uses two elements of the specification of a or b.

// Secondly, it wastes space. Due to packing of the struct the offset of data "inside"
//  the struct may be less than sizeof(package_head). In most cases the real size
// of the object that we want to construct is

offsetof(package_head, data) + N * sizeof(uint64_t)

// so we are wasting

sizeof(package_head) - offsetof(package_head, data)

// bytes.

// The above formula for the exact size is only valid for larger values of N. We must
// also ensure that we allocate at least sizeof(package_head) bytes. So the complete
// formula looks something like

#define P99_FSIZEOF(T, F, N) P99_MAXOF(sizeof(T), offsetof(T, F) + P99_SIZEOF(T, F[0]) * N)

// which is probably not something that you want to write on a daily basis.

// We provide several interfaces to allocate struct with flexible members

Херню написали какую-то. Забыли самое главное : нельзя так в лоб аллоцировать память под структуры. Потому что выравнивание может не то быть.
Надо использовать http://man7.org/linux/man-pages/man3/aligned_alloc.3.html

j123123, 12 Февраля 2019

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

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

−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

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

int main(void)
{
  char a[8], b[8];
  char *a_ptr = a+8;
  char *b_ptr = b;
  printf("a_ptr = %p, b_ptr = %p\n", a_ptr, b_ptr);
  if (a_ptr != b_ptr)
  {
    printf("a_ptr != b_ptr\n");
  }
  else
  {
    printf("a_ptr == b_ptr\n");
  }
  
  
  if ((uintptr_t)a_ptr != (uintptr_t)b_ptr)
  {
    printf("(uintptr_t)a_ptr != (uintptr_t)b_ptr\n");
  }
  else
  {
    printf("(uintptr_t)a_ptr == (uintptr_t)b_ptr\n");
  }
  return EXIT_SUCCESS;
}

Что по-вашему тут происходит?

j123123, 02 Февраля 2019

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

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

+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

/*
* Place the right command in the parameter AY temperature fine adjust
* Uses number from PPD less 11.
*/
switch (header->cupsCompression)
{
case 1 :
  strcpy(Fadjt,"{AY;-10,");
  break;
case 2 :
  strcpy(Fadjt,"{AY;-09,");
  break;
case 3 :
  strcpy(Fadjt,"{AY;-08,");
  break;
case 4 :
  strcpy(Fadjt,"{AY;-07,");
  break;
case 5 :
  strcpy(Fadjt,"{AY;-06,");
  break;
case 6 :
  strcpy(Fadjt,"{AY;-05,");
  break;
case 7 :
  strcpy(Fadjt,"{AY;-04,");
  break;
case 8 :
  strcpy(Fadjt,"{AY;-03,");
  break;
case 9 :
  strcpy(Fadjt,"{AY;-02,");
  break;
case 10 :
  strcpy(Fadjt,"{AY;-01,");
  break;
case 11 :
  strcpy(Fadjt,"{AY;+00,");
  break;
case 12 :
  strcpy(Fadjt,"{AY;+01,");
  break;
case 13 :
  strcpy(Fadjt,"{AY;+02,");
  break;
case 14 :
  strcpy(Fadjt,"{AY;+03,");
  break;
case 15 :
  strcpy(Fadjt,"{AY;+04,");
  break;
case 16 :
  strcpy(Fadjt,"{AY;+05,");
  break;
case 17 :
  strcpy(Fadjt,"{AY;+06,");
  break;
case 18 :
  strcpy(Fadjt,"{AY;+07,");
  break;
case 19 :
  strcpy(Fadjt,"{AY;+08,");
  break;
case 20 :
  strcpy(Fadjt,"{AY;+09,");
  break;
case 21 :
  strcpy(Fadjt,"{AY;+10,");
  break;
}

cykablyad, 31 Января 2019

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

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

+2

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

void add_SSE(uint8_t a[static 7], uint8_t b[static 7], uint8_t out[static 7])
{
  uint64_t a_64 = 0;
  uint64_t b_64 = 0;
  for (size_t i = 0; i < 7; i++) // можно наанроллить
  {
    a_64 |= (uint64_t)a[i] << (i*9);
    b_64 |= (uint64_t)b[i] << (i*9);
  }
  
  uint64_t c_64 = a_64 + b_64;
  
  for (size_t i = 0; i < 7; i++) // можно наанроллить
  {
    out[i] = (uint64_t)c_64 >> (i*9);
  }
}

SSE

j123123, 28 Января 2019

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

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

−3

1
2
3
4

void print_line(char *s){
    for(int i = 0; i < strlen(s); i++) putchar(s[i]);
    putchar('\n');
}

Почему C работает медленнее чем JavaScript ?

o8603054, 17 Января 2019

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

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

−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

void sort8(uint64_t a[8])
{
  uint64_t a0;
  uint64_t a1;
  uint64_t a2;
  uint64_t a3;
  uint64_t a4;
  uint64_t a5;
  uint64_t a6;
  uint64_t a7;
 
  SORT2(a[0], a[1], a0, a1);
  SORT2(a[2], a[3], a2, a3);
  SORT2(a[4], a[5], a4, a5);
  SORT2(a[6], a[7], a6, a7);

  uint64_t a_tmp[8];

  MERGE_2_4(a0, a1, a2, a3, a_tmp[0], a_tmp[1], a_tmp[2], a_tmp[3]);
  MERGE_2_4(a4, a5, a6, a7, a_tmp[4], a_tmp[5], a_tmp[6], a_tmp[7]);

  uint64_t *ptra1 = &a_tmp[0];
  uint64_t *ptra2 = &a_tmp[4];
  
  for (size_t i = 0; i < 4; i++)
  {
    if (*ptra1 < *ptra2)
    {
      a[i] = *ptra1;
      ptra1++;
    }
    else
    {
      a[i] = *ptra2;
      ptra2++;
    }
  }

  for (size_t i = 4; i < 8; i++)
  {
    if (ptra1 == &a_tmp[4])
    {
      while (ptra2 != &a_tmp[8])
      {
        a[i++] = *ptra2;
        ptra2++;
      }
      break;
    }
    
    if (ptra2 == &a_tmp[8])
    {
      while (ptra1 != &a_tmp[4])
      {
        a[i++] = *ptra1;
        ptra1++;
      }
      break;
    }


    if (*ptra1 < *ptra2)
    {
      a[i] = *ptra1;
      ptra1++;
    }
    else
    {
      a[i] = *ptra2;
      ptra2++;
    }

  }
}

Мерж сорт, специализированный на 8 элементов. Вот доказательство корректности https://paste.debian.net/hidden/cce6d31a/

j123123, 13 Января 2019

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

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

0

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

void decode_chunk(const char* s, uint8_t* out)
{
    __m128i a = _mm_loadu_si128((const __m128i*)s);

    __m128i u = _mm_and_si128(a, _mm_set1_epi8(0x74));
    u = _mm_add_epi8(u, _mm_set1_epi8(0x04));
    u = _mm_srli_epi32(u, 0x03);
    u = _mm_and_si128(u, _mm_set1_epi8(0x0F));
    u = _mm_shuffle_epi8(_mm_set_epi32(0xB9B9B9B9, 0xBFBFBFBF, 0x04041013, 0x00000000), u);
    a = _mm_add_epi8(a, u);

    __m128i m1 = _mm_set1_epi32(0xFF00FF00);
    __m128i m2 = _mm_set1_epi32(0xFFFF0000);
    a = _mm_shuffle_epi8(a, _mm_set_epi32(0x00010203, 0x04050607, 0x08090A0B, 0x0C0D0E0F));
    a = _mm_or_si128(_mm_srli_epi32(_mm_and_si128(m1, a), 2), _mm_andnot_si128(m1, a));
    a = _mm_or_si128(_mm_srli_epi32(_mm_and_si128(m2, a), 4), _mm_andnot_si128(m2, a));
    a = _mm_shuffle_epi8(a, _mm_set_epi32(0x80808080, 0x00010204, 0x05060809, 0x0A0C0D0E));

    _mm_storeu_si128((__m128i*)out, a);
}

Байтоёбский парсинг base64 (16 символов → 12 байт).

По мотивам http://govnokod.ru/12822#comment173404

bormand, 09 Января 2019

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

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

+1

001
002
003
004
005
006
007
008
009
010
011
012
013
014
015
016
017
018
019
020
021
022
023
024
025
026
027
028
029
030
031
032
033
034
035
036
037
038
039
040
041
042
043
044
045
046
047
048
049
050
051
052
053
054
055
056
057
058
059
060
061
062
063
064
065
066
067
068
069
070
071
072
073
074
075
076
077
078
079
080
081
082
083
084
085
086
087
088
089
090
091
092
093
094
095
096
097
098
099
100

int etm_readl_cp14(u32 reg, unsigned int *val)
{
	switch (reg) {
	case ETMCR:
		*val = etm_read(ETMCR);
		return 0;
	case ETMCCR:
		*val = etm_read(ETMCCR);
		return 0;
	case ETMTRIGGER:
		*val = etm_read(ETMTRIGGER);
		return 0;
	case ETMSR:
		*val = etm_read(ETMSR);
		return 0;
	case ETMSCR:
		*val = etm_read(ETMSCR);
		return 0;
	case ETMTSSCR:
		*val = etm_read(ETMTSSCR);
		return 0;
	case ETMTEEVR:
		*val = etm_read(ETMTEEVR);
		return 0;
	case ETMTECR1:
		*val = etm_read(ETMTECR1);
		return 0;
	case ETMFFLR:
		*val = etm_read(ETMFFLR);
		return 0;
	case ETMACVRn(0):
		*val = etm_read(ETMACVR0);
		return 0;
	case ETMACVRn(1):
		*val = etm_read(ETMACVR1);
		return 0;
	case ETMACVRn(2):
		*val = etm_read(ETMACVR2);
		return 0;
	case ETMACVRn(3):
		*val = etm_read(ETMACVR3);
		return 0;
	case ETMACVRn(4):
		*val = etm_read(ETMACVR4);
		return 0;
	case ETMACVRn(5):
		*val = etm_read(ETMACVR5);
		return 0;
	case ETMACVRn(6):
		*val = etm_read(ETMACVR6);
		return 0;
	case ETMACVRn(7):
		*val = etm_read(ETMACVR7);
		return 0;
	case ETMACVRn(8):
		*val = etm_read(ETMACVR8);
		return 0;
	case ETMACVRn(9):
		*val = etm_read(ETMACVR9);
		return 0;
	case ETMACVRn(10):
		*val = etm_read(ETMACVR10);
		return 0;
	case ETMACVRn(11):
		*val = etm_read(ETMACVR11);
		return 0;
	case ETMACVRn(12):
		*val = etm_read(ETMACVR12);
		return 0;
	case ETMACVRn(13):
		*val = etm_read(ETMACVR13);
		return 0;
	case ETMACVRn(14):
		*val = etm_read(ETMACVR14);
		return 0;
	case ETMACVRn(15):
		*val = etm_read(ETMACVR15);
		return 0;
	case ETMACTRn(0):
		*val = etm_read(ETMACTR0);
		return 0;
	case ETMACTRn(1):
		*val = etm_read(ETMACTR1);
		return 0;
	case ETMACTRn(2):
		*val = etm_read(ETMACTR2);
		return 0;
	case ETMACTRn(3):
		*val = etm_read(ETMACTR3);
		return 0;
	case ETMACTRn(4):
		*val = etm_read(ETMACTR4);
		return 0;
	case ETMACTRn(5):
		*val = etm_read(ETMACTR5);
		return 0;
	case ETMACTRn(6):
		*val = etm_read(ETMACTR6);
		return 0;
	...

Вроде и да, а вроде и нет

Ksyrx, 06 Января 2019

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

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