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

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

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

int IsEven(long long int number){
	if (number == 0) return 0; 
	long long int loc_num = 0;
	update: 
	
	if (number == loc_num+1) {return 1;
	} else if (number == (loc_num+1)*(-1)) { return 1;
	} else {
		if (number == loc_num+2) {return 0;
		} else if (number == (loc_num+2)*(-1)) { return 0;
		} else {
			if (number == loc_num+3) {return 1;
			} else if (number == (loc_num+3)*(-1)) { return 1;
			} else {
				if (number == loc_num+4) {return 0;
				} else if (number == (loc_num+4)*(-1)) { return 0;
				} else {
					if (number == loc_num+5) {return 1;
					} else if (number == (loc_num+5)*(-1)) { return 1;
					} else {
						if (number == loc_num+6) {return 0;
						} else if (number == (loc_num+6)*(-1)) { return 0;
						} else {
							if (number == loc_num+7) {return 1;
							} else if (number == (loc_num+7)*(-1)) { return 1;
							} else {
								if (number == loc_num+8) {return 0;
								} else if (number == (loc_num+8)*(-1)) { return 0;
								} else {
									if (number == loc_num+9) {return 1;
									} else if (number == (loc_num+9)*(-1)) { return 1;
									} else {
										if (number == loc_num+10) {return 0;
										} else if (number == (loc_num+10)*(-1)) { return 0;
										} else {
												loc_num+=10; 
												goto update;
											}
										}
									}
								}
							}
						}
					}
				}
			}
		}
	}

TurboLyudoed, 14 Ноября 2024

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

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

0

1

Админ - уебок, хранивший пароли открытым текстом

Чекайте свои мыла в утечках, ебланы

aleksusklim, 26 Октября 2024

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

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

−2

1

Удалите мой аккаунт

Удалите мой аккаунт

aleksusklim, 25 Октября 2024

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

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

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

// https://github.com/micropython/micropython/blob/1b89c503db690967d50699abe0bfa942f6f6b15e/ports/qemu/mcu/rv32/interrupts.c#L131

const char *lookup_cause(uint32_t mcause) {
    if (mcause & 0x80000000) {
        switch (mcause & 0x7FFFFFFF) {
            case 1:
                return exception_causes[1];
            case 3:
                return exception_causes[2];
            case 5:
                return exception_causes[3];
            case 7:
                return exception_causes[4];
            case 9:
                return exception_causes[5];
            case 11:
                return exception_causes[6];
            default:
                return (mcause >= 16) ?
                       exception_causes[7] :
                       exception_causes[0];
        }
    }

    switch (mcause) {
        case 0:
            return exception_causes[8];
        case 1:
            return exception_causes[9];
        case 2:
            return exception_causes[10];
        case 3:
            return exception_causes[11];
        case 4:
            return exception_causes[12];
        case 5:
            return exception_causes[13];
        case 6:
            return exception_causes[14];
        case 7:
            return exception_causes[15];
        case 8:
            return exception_causes[16];
        case 9:
            return exception_causes[17];
        case 11:
            return exception_causes[18];
        case 12:
            return exception_causes[19];
        case 13:
            return exception_causes[20];
        case 15:
            return exception_causes[21];
        default: {
            if ((mcause >= 24 && mcause <= 31) ||
                (mcause >= 48 && mcause <= 63)) {
                return exception_causes[22];
            }

            return exception_causes[0];
        }
    }
}

Микропитухон

j123123, 18 Октября 2024

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

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

+1

1
2
3
4
5
6
7
8
9

int iseven(long long int number)
{
	struct Num {
		unsigned int x:1;
		unsigned int y:31;
		unsigned int z:32;
	} num = (*(struct Num*)(&number));
	return num.x; //Если результат 1, то нечётное.
}

Функция определения чётности числа посредством возврата младшего бита.

TurboLyudoed, 11 Октября 2024

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

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

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
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90

longlong ** FUN_14000e5a0(longlong **param_1,LPCWSTR param_2,int param_3,uint param_4)

{
  uint uVar1;
  longlong **pplVar2;
  longlong **hFile;
  longlong *plVar3;
  longlong **pplVar4;
  DWORD DVar5;
  LONG local_38;
  undefined4 uStack_34;
  
  pplVar4 = (longlong **)0x0;
  uVar1 = param_4 & 0x1f;
  if ((param_4 & 0x1f) == 0) {
    uVar1 = 2;
  }
  pplVar2 = FUN_1400119f8(DAT_1400213a0,(longlong)param_1);
  if (pplVar2 == (longlong **)0x0) {
    return (longlong **)0x0;
  }
  if (param_3 == 1) {
    DVar5 = (DWORD)((param_4 >> 0x11 & 1) != 0);
    if ((param_4 >> 0x12 & 1) != 0) {
      DVar5 = 7;
    }
    hFile = (longlong **)
            CreateFileW(param_2,0x80000000,DVar5,(LPSECURITY_ATTRIBUTES)0x0,3,0x80,(HANDLE)0x0);
LAB_14000e70c:
    if (hFile == (longlong **)0xffffffffffffffff) goto LAB_14000e7ad;
  }
  else {
    if (param_3 == 2) {
      DVar5 = (DWORD)((param_4 >> 0x11 & 1) != 0);
      if ((param_4 >> 0x12 & 1) != 0) {
        DVar5 = 7;
      }
      hFile = (longlong **)
              CreateFileW(param_2,0xc0000000,DVar5,(LPSECURITY_ATTRIBUTES)0x0,4,0x80,(HANDLE)0x0);
      goto LAB_14000e70c;
    }
    if (param_3 != 3) {
      hFile = (longlong **)CONCAT44(uStack_34,local_38);
      goto LAB_14000e70c;
    }
    DVar5 = (DWORD)((param_4 >> 0x11 & 1) != 0);
    if ((param_4 >> 0x12 & 1) != 0) {
      DVar5 = 7;
    }
    hFile = (longlong **)
            CreateFileW(param_2,0xc0000000,DVar5,(LPSECURITY_ATTRIBUTES)0x0,2,0x80,(HANDLE)0x0);
    if (hFile == (longlong **)0xffffffffffffffff) {
      hFile = (longlong **)
              CreateFileW(param_2,0x40000000,DVar5,(LPSECURITY_ATTRIBUTES)0x0,5,0,(HANDLE)0x0);
      goto LAB_14000e70c;
    }
  }
  if (hFile != (longlong **)0x0) {
    if ((DAT_14001f140 == 0) || ((param_4 >> 0x13 & 1) != 0)) {
      pplVar2[1] = (longlong *)0x0;
    }
    else {
      plVar3 = (longlong *)HeapAlloc(DAT_1400204cc,0,(longlong)DAT_14001f140);
      pplVar2[1] = plVar3;
    }
    *pplVar2 = (longlong *)hFile;
    *(int *)(pplVar2 + 2) = DAT_14001f140;
    *(undefined4 *)((longlong)pplVar2 + 0x14) = 0;
    *(uint *)(pplVar2 + 4) = uVar1;
    *(uint *)((longlong)pplVar2 + 0x24) = (uint)(param_3 == 1);
    *(undefined4 *)((longlong)pplVar2 + 0x1c) = 1;
    if ((param_3 == 2) && ((param_4 >> 0x14 & 1) != 0)) {
      local_38 = 0;
      SetFilePointer(hFile,0,&local_38,2);
    }
    pplVar4 = hFile;
    if (param_1 == (longlong **)0xffffffffffffffff) {
      pplVar4 = pplVar2;
    }
    if (pplVar4 != (longlong **)0x0) {
      return pplVar4;
    }
  }
LAB_14000e7ad:
  if (param_1 == (longlong **)0xffffffffffffffff) {
    param_1 = pplVar2;
  }
  FUN_14001192c(DAT_1400213a0,(longlong)param_1);
  return pplVar4;
}

BelCodeMonkey, 06 Октября 2024

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

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

0

1

char main[] = { 0xf0, 0x0f, 0xc7, 0xc8 };

DartPower, 10 Сентября 2024

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

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

0

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

/*
 Brainfuck-C ( http://github.com/kgabis/brainfuck-c )
 Copyright (c) 2012 Krzysztof Gabis
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
 in the Software without restriction, including without limitation the rights
 to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 copies of the Software, and to permit persons to whom the Software is
 furnished to do so, subject to the following conditions:
 
 The above copyright notice and this permission notice shall be included in
 all copies or substantial portions of the Software.
 
 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 THE SOFTWARE.
*/

#include <stdio.h>

#define OP_END          0
#define OP_INC_DP       1
#define OP_DEC_DP       2
#define OP_INC_VAL      3
#define OP_DEC_VAL      4
#define OP_OUT          5
#define OP_IN           6
#define OP_JMP_FWD      7
#define OP_JMP_BCK      8

#define SUCCESS         0
#define FAILURE         1

#define PROGRAM_SIZE    4096
#define STACK_SIZE      512
#define DATA_SIZE       65535

#define STACK_PUSH(A)   (STACK[SP++] = A)
#define STACK_POP()     (STACK[--SP])
#define STACK_EMPTY()   (SP == 0)
#define STACK_FULL()    (SP == STACK_SIZE)

struct instruction_t {
    unsigned short operator;
    unsigned short operand;
};

static struct instruction_t PROGRAM[PROGRAM_SIZE];
static unsigned short STACK[STACK_SIZE];
static unsigned int SP = 0;

int compile_bf(FILE* fp) {
    unsigned short pc = 0, jmp_pc;
    int c;
    while ((c = getc(fp)) != EOF && pc < PROGRAM_SIZE) {
        switch (c) {
            case '>': PROGRAM[pc].operator = OP_INC_DP; break;
            case '<': PROGRAM[pc].operator = OP_DEC_DP; break;
            case '+': PROGRAM[pc].operator = OP_INC_VAL; break;
            case '-': PROGRAM[pc].operator = OP_DEC_VAL; break;
            case '.': PROGRAM[pc].operator = OP_OUT; break;
            case ',': PROGRAM[pc].operator = OP_IN; break;
            case '[':
                PROGRAM[pc].operator = OP_JMP_FWD;
                if (STACK_FULL()) {
                    return FAILURE;
                }
                STACK_PUSH(pc);
                break;
            case ']':
                if (STACK_EMPTY()) {
                    return FAILURE;
                }
                jmp_pc = STACK_POP();
                PROGRAM[pc].operator =  OP_JMP_BCK;
                PROGRAM[pc].operand = jmp_pc;
                PROGRAM[jmp_pc].operand = pc;
                break;
            default: pc--; break;
        }
        pc++;
    }
    if (!STACK_EMPTY() || pc == PROGRAM_SIZE) {
        return FAILURE;
    }
    PROGRAM[pc].operator = OP_END;
    return SUCCESS;
}

int execute_bf() {
    unsigned short data[DATA_SIZE], pc = 0;
    unsigned int ptr = DATA_SIZE;
    while (--ptr) { data[ptr] = 0; }
    while (PROGRAM[pc].operator != OP_END && ptr < DATA_SIZE) {
// (...)

Интерпретатор Brainfuck.

Полный код можно посмотреть тута:
https://github.com/kgabis/brainfuck-c/blob/master/brainfuck.c

kNode, 02 Июля 2024

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

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

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

template <typename Key, typename Value, size_t TblPower = 2>
struct HashMap {
	struct Node
	{
		Key k;
		Value v;
		Node *n;

		Node(const Key &key, const Value &value) :
			k(key), v(value), n(NULL) {}

		Node(const Key &key) :
			k(key), v(), n(NULL) {}
	};

	constexpr static size_t TblSize = 1U << TblPower;
	Node *table[TblSize] = {nullptr};

	HashMap() {
	}

	~HashMap() {
		for(size_t i = 0; i < TblSize; i++)
		{
			Node *entry = table[i];
			while(entry)
			{
				Node *prev = entry;
				entry = entry->n;
				delete prev;
			}
			table[i] = NULL;
		}
	}

	size_t HashFunc(const Key &key) const
	{
		/// TODO: string hash?
		// handle hash: handle pointers usually aligned
		return (((size_t) key) >> 8)  & (TblSize - 1);
	}

	// just in case: check existance or constant access
	forceinline Value *GetPtr(const Key &key) const
	{
		size_t hashValue = HashFunc(key);
		Node *entry = table[hashValue];
		while(likely(entry))
		{
			if(entry->k == key)
				return &entry->v;
			entry = entry->n;
		}
		return nullptr;
	}

	Value &operator [] (const Key &key)
	{
		return GetOrAllocate(key);
	}

#define HASHFIND(key) \
		size_t hashValue = HashFunc(key); \
		Node *prev = NULL; \
		Node *entry = table[hashValue]; \
	\
		while(entry && entry->k != key) \
		{ \
			prev = entry; \
			entry = entry->n; \
		}

	Node * noinline _Allocate(Key key, size_t hashValue, Node *prev, Node *entry)
	{
		entry = new Node(key);
		if(unlikely(!entry))
		{
			static Node error(key);
			return &error;
		}

		if(prev == NULL)
			table[hashValue] = entry;
		else
			prev->n = entry;
		return entry;
	}

	Value& GetOrAllocate(const Key &key)
	{
		HASHFIND(key);

		if(unlikely(!entry))
			entry = _Allocate(key,hashValue, prev, entry);

		return entry->v;
	}
// тут был ещё один метод, но в говнокод не влез
}

когда СГОРЕЛО от STL

mittorn, 04 Марта 2024

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

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

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
69
70
71
72
73
74
75

struct HashArrayMap {

	struct Node
	{
		Key k;
		Value v;

		Node(const Key &key, const Value &value) :
			k(key), v(value){}
		Node(const Key &key) :
			k(key), v(){}
	};

	constexpr static size_t TblSize = 1U << TblPower;
	GrowArray<Node> table[TblSize];

	HashArrayMap() {
	}

	~HashArrayMap() {
	}

	size_t HashFunc(const Key &key) const
	{
		/// TODO: string hash?
		// handle hash: handle pointers usually aligned
		return (((size_t) key) >> 8)  & (TblSize - 1);
	}

	// just in case: check existance or constant access
	Value *GetPtr(const Key &key) const
	{
		size_t hashValue = HashFunc(key);
		const GrowArray<Node> &entry = table[hashValue];
		for(int i = 0; i < entry.count; i++)
		{
			if(entry[i].k == key)
				return &entry[i].v;
		}
		return nullptr;
	}

	Value &operator [] (const Key &key)
	{
		return GetOrAllocate(key);
	}

#define HASHFIND(key) \
	GrowArray<Node> &entry = table[HashFunc(key)]; \
	int i; \
	for(i = 0; i < entry.count; i++) \
		if( entry[i].k == key ) \
			break;

	Value& GetOrAllocate(const Key &key)
	{
		HASHFIND(key);
		if(i == entry.count )
			entry.Add(Node(key));

		return entry[i].v;
	}

	bool Remove(const Key &key)
	{
		HASHFIND(key);
		if(i != entry.count)
		{
			entry.RemoveAt(i);
			return true;
		}
		return false;
	}
#undef HASHFIND
};

когда СГОРЕЛО от STL

mittorn, 04 Марта 2024

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

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

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

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

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

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

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

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

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

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

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

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