1. C++ / Говнокод #27787

    +1

    1. 01
    2. 02
    3. 03
    4. 04
    5. 05
    6. 06
    7. 07
    8. 08
    9. 09
    10. 10
    11. 11
    12. 12
    13. 13
    14. 14
    15. 15
    16. 16
    17. 17
    18. 18
    19. 19
    20. 20
    21. 21
    22. 22
    23. 23
    24. 24
    25. 25
    26. 26
    27. 27
    28. 28
    29. 29
    30. 30
    31. 31
    32. 32
    33. 33
    34. 34
    35. 35
    36. 36
    37. 37
    38. 38
    39. 39
    40. 40
    41. 41
    42. 42
    43. 43
    44. 44
    45. 45
    46. 46
    47. 47
    48. 48
    49. 49
    50. 50
    51. 51
    52. 52
    53. 53
    54. 54
    55. 55
    56. 56
    57. 57
    58. 58
    59. 59
    60. 60
    61. 61
    62. 62
    63. 63
    64. 64
    65. 65
    #include <string>
    #include <type_traits>
    #include <iostream>
    
    template<int N> struct tag {};
    
    template<typename T, int N>
    struct loophole_t
    {
        friend auto loophole(tag<N>) { return T{}; };
    };
    
    #define BA(c) auto loophole(tag< (c) >);
    #define Cb(c) BA(c) BA(c+1) BA(c+2) BA(c+3) BA(c+4)
    #define KA(c) Cb(c) Cb(c+5) Cb(c+10) Cb(c+15) Cb(c+20)
    #define ZDES(c) KA(c) KA(c+20) KA(c+40) KA(c+60) KA(c+80)
    #define BACbKAZDES ZDES(0) ZDES(80) ZDES(160) ZDES(240) ZDES(300)
    
    BACbKAZDES
    
    template<int I>
    struct wrp
    {
        int a;
    };
    int main(void)
    {
        sizeof(loophole_t<wrp<67>, 0>);
        sizeof(loophole_t<wrp<66>, 1>);
        sizeof(loophole_t<wrp<68>, 2>);
        sizeof(loophole_t<wrp<99>, 3>);
        sizeof(loophole_t<wrp<76>, 4>);
        sizeof(loophole_t<wrp<66>, 5>);
        sizeof(loophole_t<wrp<33>, 6>);
        sizeof(loophole_t<wrp<73>, 7>);
        sizeof(loophole_t<wrp<66>, 8>);
        sizeof(loophole_t<wrp<68>, 9>);
        sizeof(loophole_t<wrp<85>, 10>);
        sizeof(loophole_t<wrp<70>, 11>);
        sizeof(loophole_t<wrp<79>, 12>);
        sizeof(loophole_t<wrp<99>, 13>);
        sizeof(loophole_t<wrp<76>, 14>);
        sizeof(loophole_t<wrp<66>, 15>);
        sizeof(loophole_t<wrp<33>, 16>);
        sizeof(loophole_t<wrp<109>, 17>);
        sizeof(loophole_t<wrp<112>, 18>);
        sizeof(loophole_t<wrp<119>, 19>);
        sizeof(loophole_t<wrp<102>, 20>);
    
        std::string nactenbka;
    #define L(c, i) if(std::is_same< wrp< (c) >, decltype( loophole(tag< (i) >{}) )>::value) nactenbka.push_back((char)( c-1 ) );
    #define O(c, i) L(c, i) L(c+1, i) L(c+2, i) L(c+3, i) L(c+4, i)
    #define V(c, i) O(c, i) O(c+5, i) O(c+10,i) O(c+15,i) O(c+20,i)
    #define E(c, i) V(c, i) V(c+20,i) V(c+40,i) V(c+60,i) V(c+80,i)
    #define LOVE(c, i) E(c, i) V(c+80, i) V(c+100, i)
    
    #define FORE(i) LOVE(0, i)
    #define VER(i) FORE(i) FORE(i+1) FORE(i+2) FORE(i+3) FORE(i+4)
    #define FOREVER VER(0) VER(5) VER(10) VER(15) FORE(20)
        FOREVER
    
        std::cout << nactenbka << std::endl;
        return 0;
    
    }

    <3

    BACbKA, 04 Ноября 2021

    Комментарии (9)
  2. C++ / Говнокод #27785

    +3

    1. 01
    2. 02
    3. 03
    4. 04
    5. 05
    6. 06
    7. 07
    8. 08
    9. 09
    10. 10
    11. 11
    12. 12
    13. 13
    14. 14
    15. 15
    16. 16
    17. 17
    18. 18
    19. 19
    20. 20
    21. 21
    22. 22
    23. 23
    24. 24
    25. 25
    26. 26
    27. 27
    28. 28
    29. 29
    30. 30
    31. 31
    32. 32
    33. 33
    34. 34
    35. 35
    36. 36
    37. 37
    38. 38
    39. 39
    40. 40
    41. 41
    42. 42
    43. 43
    44. 44
    45. 45
    46. 46
    47. 47
    48. 48
    49. 49
    50. 50
    51. 51
    52. 52
    53. 53
    54. 54
    55. 55
    56. 56
    57. 57
    58. 58
    59. 59
    template<typename T>
    static ALWAYS_INLINE void FormatLogMessageAndPrintW(
                                                 const char* channelName, 
                                                 const char* functionName, 
                                                 LOGLEVEL level,
                                                 const char* message, 
                                                 bool timestamp, 
                                                 bool ansi_color_code,
                                                 bool newline, 
                                                 const T& callback)
    {
      char buf[512];
      char* message_buf = buf;
      int message_len;
      if ((message_len = FormatLogMessageForDisplay(message_buf,
                           sizeof(buf), channelName, functionName,
                           level, 
                           message, timestamp,
                           ansi_color_code, newline)) > (sizeof(buf) - 1))
      {
        message_buf = static_cast<char*>(std::malloc(message_len + 1));
        message_len = FormatLogMessageForDisplay(message_buf, 
                     message_len + 1, channelName, functionName, 
                     level, message, timestamp, ansi_color_code, newline);
      }
      if (message_len <= 0)
        return;
    
      // Convert to UTF-16 first so unicode characters display correctly.
      // NT is going to do it anyway...
      wchar_t wbuf[512];
      wchar_t* wmessage_buf = wbuf;
      int wmessage_buflen = countof(wbuf) - 1;
      if (message_len >= countof(wbuf))
      {
        wmessage_buflen = message_len;
        wmessage_buf = static_cast<wchar_t*>
                   (std::malloc((wmessage_buflen + 1) * sizeof(wchar_t)));
      }
    
      wmessage_buflen = MultiByteToWideChar(CP_UTF8, 0, message_buf,
                        message_len, wmessage_buf, wmessage_buflen);
    
      if (wmessage_buflen <= 0)
        return;
    
      wmessage_buf[wmessage_buflen] = '\0';
      callback(wmessage_buf, wmessage_buflen);
    
      if (wmessage_buf != wbuf)
      {
        std::free(wbuf);                        // <=
      }
    
      if (message_buf != buf)
      {
        std::free(message_buf);
      }
    }

    Отсюда:
    https://pvs-studio.com/ru/blog/posts/cpp/0880/

    HO9I6PbCKuu_neTyx, 03 Ноября 2021

    Комментарии (26)
  3. C++ / Говнокод #27781

    +2

    1. 01
    2. 02
    3. 03
    4. 04
    5. 05
    6. 06
    7. 07
    8. 08
    9. 09
    10. 10
    11. 11
    12. 12
    13. 13
    14. 14
    15. 15
    16. 16
    17. 17
    18. 18
    19. 19
    20. 20
    21. 21
    22. 22
    23. 23
    24. 24
    25. 25
    26. 26
    27. 27
    28. 28
    29. 29
    30. 30
    31. 31
    32. 32
    33. 33
    34. 34
    35. 35
    36. 36
    37. 37
    38. 38
    39. 39
    40. 40
    41. 41
    42. 42
    43. 43
    44. 44
    45. 45
    46. 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)
  4. C++ / Говнокод #27777

    +1

    1. 01
    2. 02
    3. 03
    4. 04
    5. 05
    6. 06
    7. 07
    8. 08
    9. 09
    10. 10
    11. 11
    12. 12
    13. 13
    14. 14
    15. 15
    16. 16
    17. 17
    18. 18
    19. 19
    20. 20
    21. 21
    22. 22
    23. 23
    24. 24
    25. 25
    26. 26
    27. 27
    28. 28
    29. 29
    30. 30
    31. 31
    32. 32
    33. 33
    34. 34
    35. 35
    36. 36
    37. 37
    38. 38
    39. 39
    40. 40
    41. 41
    42. 42
    43. 43
    44. 44
    45. 45
    46. 46
    47. 47
    48. 48
    49. 49
    50. 50
    51. 51
    52. 52
    53. 53
    54. 54
    55. 55
    56. 56
    57. 57
    58. 58
    59. 59
    60. 60
    61. 61
    62. 62
    63. 63
    64. 64
    65. 65
    66. 66
    67. 67
    68. 68
    69. 69
    70. 70
    71. 71
    72. 72
    73. 73
    74. 74
    75. 75
    76. 76
    77. 77
    78. 78
    79. 79
    80. 80
    81. 81
    82. 82
    83. 83
    84. 84
    85. 85
    86. 86
    87. 87
    88. 88
    89. 89
    90. 90
    91. 91
    92. 92
    93. 93
    94. 94
    95. 95
    96. 96
    97. 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)
  5. C++ / Говнокод #27776

    +2

    1. 01
    2. 02
    3. 03
    4. 04
    5. 05
    6. 06
    7. 07
    8. 08
    9. 09
    10. 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)
  6. C++ / Говнокод #27775

    0

    1. 01
    2. 02
    3. 03
    4. 04
    5. 05
    6. 06
    7. 07
    8. 08
    9. 09
    10. 10
    11. 11
    12. 12
    13. 13
    14. 14
    15. 15
    16. 16
    17. 17
    18. 18
    19. 19
    20. 20
    21. 21
    22. 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)
  7. C++ / Говнокод #27774

    0

    1. 1
    2. 2
    3. 3
    4. 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)
  8. C++ / Говнокод #27768

    0

    1. 1
    2. 2
    3. 3
    4. 4
    5. 5
    6. 6
    7. 7
    8. 8
    auto DivisibleBy = [](int d)
        {
            return [d](int m) { return m % d == 0; };
        };
     
        if (ranges::any_of(v, DivisibleBy(7))) {
            std::cout << "At least one number is divisible by 7\n";
        }

    https://en.cppreference.com/w/cpp/algorithm/ranges/all_any_none_of

    digitalEugene, 26 Октября 2021

    Комментарии (73)
  9. C++ / Говнокод #27761

    −1

    1. 1
    2. 2
    3. 3
    4. 4
    5. 5
    for (k = k + 0, j = 0; j < m; j++)
    {
        b[k] = mat[i][j];
        cout << b[k];
    }

    Увидел в лабе у чела из универа. Почему бы лишний раз не присвоить k собственное значение

    VladimirM4K, 21 Октября 2021

    Комментарии (11)
  10. C++ / Говнокод #27758

    0

    1. 01
    2. 02
    3. 03
    4. 04
    5. 05
    6. 06
    7. 07
    8. 08
    9. 09
    10. 10
    11. 11
    12. 12
    13. 13
    14. 14
    15. 15
    16. 16
    17. 17
    18. 18
    19. 19
    20. 20
    21. 21
    #include <string>
    #include <iostream>
     
    int foo() {
    	std::string str = "file://*";
    	std::cout << str << std::endl;
    	return 0;
    }
     
    /*
    int bar() {
    	std::string str = "file://*";       // warning: '/*' within block comment [-Wcomment]
    	std::cout << str << std::endl;
    	return 0;
    }
    */
     
    int main() {
    	foo();
    	//bar();
    }

    Какой багор

    https://ideone.com/NiXH2q

    3_dar, 19 Октября 2021

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