По колено в коде — Говнокод.ру

C++ / Говнокод #27781

+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

uint16_t Mnemonic::describeMnemonics(void) const
{
	uint16_t result = 0;
	size_t i = 0;
	for (auto&& m : mnemonics)
		result += m.index() << i++ * 4;

	return result;
}
...
switch(mnemonic.describeMnemonics())
{
	case constructDescription(REGISTER, REGISTER):
	{
...
	}
	break;

	case constructDescription(REGISTER, CONSTANT):
	{
...
	}
	break;

	case constructDescription(REGISTER, LABEL):
	{
...
	}
	break;

	case constructDescription(REGISTER, INDIRECT_ADDRESS):
	{
...
	}
	break;

	case constructDescription(INDIRECT_ADDRESS, REGISTER):
	{
...
	}
	break;

	default:
		break;

}

спасибо папочка за паттерн матчинг

digitalEugene, 01 Ноября 2021

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

Куча / Говнокод #27780

+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

(** Set of all possible interleaving of two traces is a trace
  ensemble. As we later prove in [interleaving_to_permutation], this
  definition is dual to [Permutation]. *)
  Inductive Interleaving : list TE -> list TE -> TraceEnsemble :=
  | ilv_cons_l : forall te t1 t2 t,
      Interleaving t1 t2 t ->
      Interleaving (te :: t1) t2 (te :: t)
  | ilv_cons_r : forall te t1 t2 t,
      Interleaving t1 t2 t ->
      Interleaving t1 (te :: t2) (te :: t)
  | ilv_nil : Interleaving [] [] [].

Попытка оптимизации:

  (* Left-biased version of [Interleaving] that doesn't make
  distinction between schedulings of commuting elements: *)
  Inductive UniqueInterleaving : list TE -> list TE -> TraceEnsemble :=
  | uilv_cons_l : forall l t1 t2 t,
      UniqueInterleaving t1 t2 t ->
      UniqueInterleaving (l :: t1) t2 (l :: t)
  | uilv_cons_r1 : forall l r t1 t2 t,
      ~trace_elems_commute l r ->
      UniqueInterleaving (l :: t1) t2 (l :: t) ->
      UniqueInterleaving (l :: t1) (r :: t2) (r :: l :: t)
  | uilv_cons_r2 : forall r1 r2 t1 t2 t,
      UniqueInterleaving t1 (r1 :: t2) (r1 :: t) ->
      UniqueInterleaving t1 (r2 :: r1 :: t2) (r2 :: r1 :: t)
  | uilv_nil : forall t, UniqueInterleaving [] t t.

Сложный говнокод. Почему вторая "оптимизированная" версия работает хуже первой?

CHayT, 01 Ноября 2021

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

Куча / Говнокод #27779

0

1
2

Be gone, malicious spirit from the anus!
We don't say "amen", because we may step on the mines; we say "True"!

Херня рулит.

nPOnOBeDHuK, 01 Ноября 2021

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

Куча / Говнокод #27778

0

1

https://twitter.com/RCS/status/1452367702727831565

Ай, Молодца !!!

gne4do, 31 Октября 2021

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

C++ / Говнокод #27777

+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
95
96
97

if (op.size() == 1)
				{
					if (op[0].id == LexemID::REGISTER)
					{
						if (isSIBbase(registerName2registerId.at( std::get<std::string>(op[0].lexemas))))
							mnemonic.mnemonics.emplace_back(IndirectAddress{
								.base = Register(std::get<std::string>(op[0].lexemas))
								});
						else
							mnemonic.mnemonics.emplace_back(IndirectAddress{
								.index = Register(std::get<std::string>(op[0].lexemas))
								});
					}
					else if (op[0].id == LexemID::LABEL_USE)
						mnemonic.mnemonics.emplace_back(IndirectAddress{
							.disp = LabelUse(std::get<std::string>(op[0].lexemas))
							});
					else if (op[0].id == LexemID::NUMBER)
						mnemonic.mnemonics.emplace_back(IndirectAddress{
							.disp = Constant(std::get<int>(op[0].lexemas))
							});
				}
				else if (op.size() == 3)
				{
					if (const auto operation = std::get<std::string>(op[1].lexemas)[0]; operation == '+')
					{
						if (op[0].id == LexemID::REGISTER && op[2].id == LexemID::REGISTER)
						{
							if (isSIBbase(registerName2registerId.at(std::get<std::string>(op[0].lexemas))))
								mnemonic.mnemonics.emplace_back(IndirectAddress{
									.base = Register(std::get<std::string>(op[0].lexemas)),
									.index = Register(std::get<std::string>(op[2].lexemas))
									});
							else
								mnemonic.mnemonics.emplace_back(IndirectAddress{
									.base = Register(std::get<std::string>(op[2].lexemas)),
									.index = Register(std::get<std::string>(op[0].lexemas))
									});
						}
						else if (op[0].id == LexemID::REGISTER && op[2].id == LexemID::NUMBER)
						{
							if (isSIBbase(registerName2registerId.at(std::get<std::string>(op[0].lexemas))))
								mnemonic.mnemonics.emplace_back(IndirectAddress{
									.base = Register(std::get<std::string>(op[0].lexemas)),
									.disp = Constant(std::get<int>(op[2].lexemas))
									});
							else
								mnemonic.mnemonics.emplace_back(IndirectAddress{
									.index = Register(std::get<std::string>(op[0].lexemas)),
									.disp = Constant(std::get<int>(op[2].lexemas))
									});
						}
						else if (op[0].id == LexemID::REGISTER && op[2].id == LexemID::LABEL_USE)
						{
							if (isSIBbase(registerName2registerId.at(std::get<std::string>(op[0].lexemas))))
								mnemonic.mnemonics.emplace_back(IndirectAddress{
									.base = Register(std::get<std::string>(op[0].lexemas)),
									.disp = LabelUse(std::get<std::string>(op[2].lexemas))
									});
							else
								mnemonic.mnemonics.emplace_back(IndirectAddress{
								.index = Register(std::get<std::string>(op[0].lexemas)),
								.disp = LabelUse(std::get<std::string>(op[2].lexemas))
									});
						}
					}
					else if (operation == '*')
					{
						if (op[0].id == LexemID::NUMBER && op[2].id == LexemID::REGISTER)
							mnemonic.mnemonics.emplace_back(IndirectAddress{
								.base = Register(std::get<std::string>(op[2].lexemas)),
								.scale = static_cast<uint8_t>(std::get<int>(op[0].lexemas))
								});
					}
				}
				else if(op.size() == 5)
				{

					if (op[4].id == LexemID::REGISTER)
						mnemonic.mnemonics.emplace_back(IndirectAddress{
							.base  = Register(std::get<std::string>(op[4].lexemas)),
							.index = Register(std::get<std::string>(op[2].lexemas)),
							.scale = static_cast<uint8_t>(std::get<int>(op[0].lexemas))
							});
					else if (op[4].id == LexemID::NUMBER)
						mnemonic.mnemonics.emplace_back(IndirectAddress{
							.index = Register(std::get<std::string>(op[2].lexemas)),
							.scale = static_cast<uint8_t>(std::get<int>(op[0].lexemas)),
							.disp = Constant(std::get<int>(op[4].lexemas))
							});
					else if (op[4].id == LexemID::LABEL_USE)
						mnemonic.mnemonics.emplace_back(IndirectAddress{
							.index = Register(std::get<std::string>(op[2].lexemas)),
							.scale = static_cast<uint8_t>(std::get<int>(op[0].lexemas)),
							.disp = LabelUse(std::get<std::string>(op[4].lexemas))
							});
...

чё к щам близко?

https://github.com/kcalbSphere/PVC-16/blob/master/pvc-asm/syntaxer.cpp

digitalEugene, 31 Октября 2021

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

C++ / Говнокод #27776

+2

01
02
03
04
05
06
07
08
09
10

// a.h
inline struct $q1 {unsigned a;} $q1i;

// main.cpp
#include "a.h"
int main(int argc, char** args) 
{
    $q1i.a = argc; 
    return $q1i.a;
};

у некоторых линукс-юзеров может упасть на этапе линковки

digitalEugene, 31 Октября 2021

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

C++ / Говнокод #27775

0

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

#define REGISTERS_LIST A, B, C, D, E, SI, BP, SP, IP
#define LREGISTERS_LIST AH, AL, BH, BL, CH, CL, DH, DL, EH, EL, SIH, SIL, BPH, BPL, SPH, SPL, IPH, IPL

enum RegisterID
{
	REGISTERS_LIST,
	LREGISTERS_LIST
};

const static std::string registerId2registerName[] = {
#define _MAP(x) #x
	MAP_LIST(_MAP, REGISTERS_LIST),
	MAP_LIST(_MAP, LREGISTERS_LIST)
};
#undef _MAP

const static std::map<std::string, RegisterID> registerName2registerId = {
#define _MAP(x) {#x, x}
	MAP_LIST(_MAP, REGISTERS_LIST),
	MAP_LIST(_MAP, LREGISTERS_LIST)
};
#undef _MAP

покруче гомоиконности

digitalEugene, 30 Октября 2021

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

C++ / Говнокод #27774

0

1
2
3
4

const boost::escaped_list_separator<char> els("\\"s, " \n\t"s, "\"");

boost::replace_all(src, "\"", "\"\\\"");
const boost::tokenizer tok(src, els);

els не умеет в keeping quotes хнык хнык

digitalEugene, 30 Октября 2021

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

C# / Говнокод #27773

0

01
02
03
04
05
06
07
08
09
10
11

private List<OutputData> AddSomeSpecialStateToFoo(
            List<OutputData> foos,
            IDictionary<Guid, SomeSpecialState> fooStates)
        {
            foreach(var foo in foos)
            {
                foo .State = fooStates.FirstOrDefault(x => x.Key == cam.FooId).Value;
            }

            return foos;
        }

Митируем листы и юзаем словарь правильно.

LozorcevDiyosha, 29 Октября 2021

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

JavaScript / Говнокод #27772

0

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

interface Something {
    r: number;
    g: number;
    b: number;
    toString: () => string;
}

function main() {
    const something = {
        r: 11.0, g: 12.0, b: 13.0, toString() {
            return "Hello " + this.b;
        }
    };

    const iface = <Something>something;
    print(iface.toString());

    print("done.");
}

Интерфесы для абстрактых обьектов.. а ваш говно компилятор может так?

ASD_77, 28 Октября 2021

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

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