1. Список говнокодов пользователя j123123

    Всего: 266

  2. Assembler / Говнокод #25867

    +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
    #include <stdbool.h>
    
    bool impl(bool a, bool b) // ->
    {
        return (!a || b);
    }
    
    bool always_true(bool a, bool b)
    {
        return (impl(a,b) == impl(b,a)) == (a == b); // ( (a -> b) = (b -> a) ) = (a = b) tautology
    }
    
    /*
    GCC не хочет мне тавтологию оптимизировать!
    https://godbolt.org/z/kgFMpR
    always_true:
            movl    %esi, %eax
            xorl    %edi, %eax
            cmpb    %dil, %sil
            sete    %dl
            xorl    %edx, %eax
            ret
    Но Clang может
    https://godbolt.org/z/YcOat-
    always_true:                            # @always_true
            movb    $1, %al
            retq
    */

    ГОВНО!

    j123123, 24 Сентября 2019

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

    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
    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
    // https://www.opennet.ru/opennews/art.shtml?num=51508
    // Microsoft открыл код стандартной библиотеки С++, поставляемой в Visual Studio 
    
    // https://github.com/microsoft/STL/blob/7f65140761947af4ed7f9dfc11adee8c86c9e4c2/stl/inc/unordered_map#L712
    
    #if _HAS_CXX17
    template <class _Iter, class _Hasher = hash<_Guide_key_t<_Iter>>, class _Keyeq = equal_to<_Guide_key_t<_Iter>>,
        class _Alloc = allocator<_Guide_pair_t<_Iter>>,
        enable_if_t<
            conjunction_v<_Is_iterator<_Iter>, _Is_hasher<_Hasher>, negation<_Is_allocator<_Keyeq>>, _Is_allocator<_Alloc>>,
            int> = 0>
    unordered_map(_Iter, _Iter, _Guide_size_type_t<_Alloc> = 0, _Hasher = _Hasher(), _Keyeq = _Keyeq(), _Alloc = _Alloc())
        ->unordered_map<_Guide_key_t<_Iter>, _Guide_val_t<_Iter>, _Hasher, _Keyeq, _Alloc>;
    
    template <class _Kty, class _Ty, class _Hasher = hash<_Kty>, class _Keyeq = equal_to<_Kty>,
        class _Alloc = allocator<pair<const _Kty, _Ty>>,
        enable_if_t<conjunction_v<_Is_hasher<_Hasher>, negation<_Is_allocator<_Keyeq>>, _Is_allocator<_Alloc>>, int> = 0>
    unordered_map(initializer_list<pair<_Kty, _Ty>>, _Guide_size_type_t<_Alloc> = 0, _Hasher = _Hasher(), _Keyeq = _Keyeq(),
        _Alloc = _Alloc())
        ->unordered_map<_Kty, _Ty, _Hasher, _Keyeq, _Alloc>;
    
    template <class _Iter, class _Alloc, enable_if_t<conjunction_v<_Is_iterator<_Iter>, _Is_allocator<_Alloc>>, int> = 0>
    unordered_map(_Iter, _Iter, _Alloc)
        ->unordered_map<_Guide_key_t<_Iter>, _Guide_val_t<_Iter>, hash<_Guide_key_t<_Iter>>, equal_to<_Guide_key_t<_Iter>>,
            _Alloc>;
    
    template <class _Iter, class _Alloc, enable_if_t<conjunction_v<_Is_iterator<_Iter>, _Is_allocator<_Alloc>>, int> = 0>
    unordered_map(_Iter, _Iter, _Guide_size_type_t<_Alloc>, _Alloc)
        ->unordered_map<_Guide_key_t<_Iter>, _Guide_val_t<_Iter>, hash<_Guide_key_t<_Iter>>, equal_to<_Guide_key_t<_Iter>>,
            _Alloc>;
    
    template <class _Iter, class _Hasher, class _Alloc,
        enable_if_t<conjunction_v<_Is_iterator<_Iter>, _Is_hasher<_Hasher>, _Is_allocator<_Alloc>>, int> = 0>
    unordered_map(_Iter, _Iter, _Guide_size_type_t<_Alloc>, _Hasher, _Alloc)
        ->unordered_map<_Guide_key_t<_Iter>, _Guide_val_t<_Iter>, _Hasher, equal_to<_Guide_key_t<_Iter>>, _Alloc>;
    
    template <class _Kty, class _Ty, class _Alloc, enable_if_t<_Is_allocator<_Alloc>::value, int> = 0>
    unordered_map(initializer_list<pair<_Kty, _Ty>>, _Alloc)->unordered_map<_Kty, _Ty, hash<_Kty>, equal_to<_Kty>, _Alloc>;
    
    template <class _Kty, class _Ty, class _Alloc, enable_if_t<_Is_allocator<_Alloc>::value, int> = 0>
    unordered_map(initializer_list<pair<_Kty, _Ty>>, _Guide_size_type_t<_Alloc>, _Alloc)
        ->unordered_map<_Kty, _Ty, hash<_Kty>, equal_to<_Kty>, _Alloc>;
    
    template <class _Kty, class _Ty, class _Hasher, class _Alloc,
        enable_if_t<conjunction_v<_Is_hasher<_Hasher>, _Is_allocator<_Alloc>>, int> = 0>
    unordered_map(initializer_list<pair<_Kty, _Ty>>, _Guide_size_type_t<_Alloc>, _Hasher, _Alloc)
        ->unordered_map<_Kty, _Ty, _Hasher, equal_to<_Kty>, _Alloc>;
    #endif // _HAS_CXX17

    Ну и хуйня! Впрочем, разве могло быть иначе?

    j123123, 18 Сентября 2019

    Комментарии (174)
  4. C++ / Говнокод #25842

    +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
    // https://habr.com/ru/post/466985/
    
    // о каррировании в крестоговне
    
    // По сути это каррирующее говно просто складывает куда-то хуйню, а потом целиком ее в функцию призывает.
    // Ну т.е. на Си можно написать дрисню вида
    
    int shit(int a, int b, int c, int d)
    {
      return a*(b+c*d);
    }
    
    // И вот каррирование такой дрисни это как если б я сделал структуру
    struct shit_arguments
    {
       int a;
       int b;
       int c;
       int d;
    };
    
    // И потом бы с конца заполнял это говно
    struct shit_arguments;
    shit_arguments.d = 13;
    shit_arguments.c = 666;
    shit_arguments.b = 1488;
    shit_arguments.a = 42;
    // и при полном заполнении этого говна просто б вызвал функцию
    // подставив туда накопившееся говно
    int somecrap = shit(shit_arguments.a, shit_arguments.b, shit_arguments.c, shit_arguments.d);
    
    // именно так эта крестовая дрисня и работает, она не может произвести частичное вычисление
    // не может сделать функцию с частично вычисленной дрисней в ней на основе частично переданной хуйни
    
    // если я например в функцию shit захочу частично подставить аргументы b,c,d как 1,2,3 то у меня не получится функции вида
    int shit_b1_c2_d3(int a)
    {
      return a*(7); // 1+2*3 = 7
    }
    // Нихуя подобного не будет. А если нихуя подобного нет, нахуй это бесполезное дерьмо вообще надо?
    // В крестах никак нельзя на основе каких-то готовых функций сгенерить
    // видоизмененные функции с частично сделанными вычислениями
    // Никакой нормальной рефлексии нет, просто какие-то тупые кривые костыли к сишечке налепили
    // И это программисты?

    j123123, 15 Сентября 2019

    Комментарии (69)
  5. Куча / Говнокод #25841

    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
    (set-logic LIA)
    ;(set-option :produce-proofs true)
    
    (define-fun-rec add_via_add1 ((a Int) (b Int)) Int
      (ite (= b 0) a                                ; if (b == 0) return a 
        (ite (< b 0) (- (add_via_add1 (- a) (- b))) ; if (b < 0) return add_via_add(-a,-b)
          (+ (add_via_add1 a (- b 1)) 1)            ; return add_via_add(a, b-1) + 1;
        )
      )
    )
    
    
    (assert
      (not (forall ((a Int) (b Int))
        (= (add_via_add1 a b) (+ a b))
      ))
    )
    
    (check-sat)
    (get-model)
    (exit)

    Хуйня, которую SMT солверы Z3 и CVC4 доказать не могут. Надо переходить на Coq, Metamath, LEAN, Mizar или еще какую-то такую хуйню

    j123123, 15 Сентября 2019

    Комментарии (9)
  6. Си / Говнокод #25602

    −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
    // вообще, есть одна говнистая особенность сишки:
    // нельзя вернуть из функции массив хуйпойми какой длины, выделив память чисто на стеке
    // Вот например:
    
    char *a_ret (size_t len)
    {
      char *ret = alloca(len);
      memset(ret, 'a', len);
      return ret; // так нельзя
    }
    
    // т.е. надо делать как-нибудь вот так
    char *a_ret (size_t len)
    {
      char *ret = malloc(len);
      if (ret == NULL)
      {
        exit(ENOMEM);
      }
      memset(ret, 'a', len);
      return ret;
    }

    Но это ж на самом-то деле говно какое-то. Дергать аллокаторы какие-то, ради каких-то мелких кусков байтиков.
    Почему не сделать хуйни, чтоб вызываемая функция как бы приосталавливалась и просила ту функцию, которая ее вызывает, чтоб она вот такой-то alloca() сделала нужного размера в своем стекфрейме, а потом туда вот та вызванная функция байтики уже вхерачивала? Ну т.е. можно сделать отдельный свой стек для локальных переменных тех функций, которые должны уметь такую хуйню делать (т.е. просить вызвавшую их функцию "а сделай ка там себе alloca(123) и дай мне указатель, а я в него насру")
    Вообще хуйня какая-то, сишка слишком сильно сковывает всякой своей хуйней, соглашениями вызовов, всякими ABI там. То ли дело ассемблер!

    j123123, 15 Мая 2019

    Комментарии (90)
  7. Куча / Говнокод #25578

    +1

    1. 1
    2. 2
    3. 3
    https://tass.ru/nacionalnye-proekty/6391295
    
    Томские ученые разработали первое в России программное обеспечение, независимое от Windows

    ШОК! Томские ученые открыли способ создавать программное обеспечение, независимое от Windows. Нужно всего лишь…

    j123123, 30 Апреля 2019

    Комментарии (44)
  8. C++ / Говнокод #25577

    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
    23. 23
    // https://github.com/QWalk/mainline/blob/b12ea3652226caef23c2f5fc7b168746c89096f2/src/system/Pseudopotential_so.cpp#L36
    
    doublevar legendre_so(doublevar x, int n)
    {
      switch(n)
      {
      case 0:
        return 1;
      case 1:
        return x;
      case 2:
        return .5*(3*x*x-1);
      case 3:
        return .5*(5*x*x*x - 3*x);
      case 4:
        return 0.125*(35*x*x*x*x -30*x*x +3);
      case 5:
        return 0.125*(63*x*x*x*x*x - 70*x*x*x + 15*x);
      default:
        error("Do not have legendre polynomial of order ", n);
        return 0; //shouldn't get here, but gets rid of a compiler message
      }
    }

    Вот нет чтоб через шаблоноговно нагенерировать эти свои многочлены Лагранжа.

    https://en.wikipedia.org/wiki/Legendre_polynomials#Rodrigues'_formula_and_other_explicit_formulas

    Интересно, сколько строк шаблоноговна на это придется потратить?
    И вообще, надо чтоб гомоиконность!

    j123123, 29 Апреля 2019

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

    +4

    1. 1
    2. 2
    3. 3
    4. 4
    5. 5
    6. 6
    7. 7
    8. 8
    9. 9
    #include <iostream>
    #include <string>
    #include <string_view>
    
    int main() {
      std::string s = "Hellooooooooooooooo ";
      std::string_view sv = s + "World\n";
      std::cout << sv;
    }

    https://alexgaynor.net/2019/apr/21/modern-c++-wont-save-us/
    What's happening here is that s + "World\n" allocates a new std::string, and then is converted to a std::string_view. At this point the temporary std::string is freed, but sv still points at the memory that used to be owned by it. Any future use of sv is a use-after-free vulnerability. Oops! C++ lacks the facilities for the compiler to be aware that sv captures a reference to something where the reference lives longer than the referent. The same issue impacts std::span, also an extremely modern C++ type.

    j123123, 24 Апреля 2019

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

    +2

    1. 1
    2. 2
    3. 3
    4. 4
    5. 5
    6. 6
    7. 7
    8. 8
    // https://github.com/WebKit/webkit/blob/e0e7e8f907f4c01c723374e8230a63d46e89e6a0/Source/WebCore/platform/graphics/filters/FEComposite.cpp#L98
    
    static unsigned char clampByte(int c)
    {
        unsigned char buff[] = { static_cast<unsigned char>(c), 255, 0 };
        unsigned uc = static_cast<unsigned>(c);
        return buff[!!(uc & ~0xff) + !!(uc & ~(~0u >> 1))];
    }

    j123123, 22 Апреля 2019

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

    +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
    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
    https://habr.com/ru/article/448466/
    
    */
    А последние пару лет набирает популярность boost.hana. Это boost.fusion,
    но с constexpr'ом и лямбдами. Автор hana, Луис Дионе (Louis Dionne),
    используя на полную мощь все возможности новых стандартов, в некотором
    смысле очеловечил метапрограммирование. С помощью hana всяческие
    манипуляции с типами, их кортежами, отображениями, а также компайл- и
    рантайм-работа с ними обрели практически человеческое лицо и читаемый
    вид. Ну, с поправкой на синтаксис C++, разумеется. Вот, например, как выглядит
    универсальный сериализатор структур, написанный с помощью hana:
    */
    
    // 1. Give introspection capabilities to 'Person'
    struct Person {
      BOOST_HANA_DEFINE_STRUCT(Person,
        (std::string, name),
        (int, age)
      );
    };
    // 2. Write a generic serializer (bear with std::ostream for the example)
    auto serialize = [](std::ostream& os, auto const& object) {
      hana::for_each(hana::members(object), [&](auto member) {
        os << member << std::endl;
      });
    };
    // 3. Use it
    Person john{"John", 30};
    serialize(std::cout, john);
    
    /*
    Ну да, структуры приходится описывать особым образом. А кому сейчас легко?
    И тут хочется также отметить библиотеку tinyrefl за авторством Manu Sánchez
    (Мануэля Санчеса). Довольно неплохая попытка принести в мир C++-разработки
    статическую рефлексию без расширения компилятора. Для своей работы библиотека
    требует стороннюю утилиту (cppast), но зато предоставляет довольно удобный доступ
    к информации о структурах, которую можно использовать в процессе разработки
    программы. Преимущество этой библиотеки (по сравнению с другими) в том, что для
    работы с ней не надо использовать «птичий язык», а элементы структур (как и сами
    структуры) можно произвольным образом атрибутировать прямо в исходном коде:
    */
    
    struct [[serializable]] Person {
        std::string name;
        int age;
    };
    template<typename Class>
    auto serialize(std::ostream& os, Class&& object) -> std::enable_if_t<
            tinyrefl::has_metadata<std::decay_t<Class>>() &&
            tinyrefl::has_attribute<std::decay_t<Class>>("interesting"),
        std::ostream&>
    {
        tinyrefl::visit_member_variables(object, [&os](const auto& /* name */, const auto& var) {
            os << var << std::endl;
        });
        return equal;
    }
    
    /*
    Таких примеров можно привести ещё много (или найти на гитхабе или гитлабе).
    Объединяет все эти библиотеки и инструменты одна особенность: значительно
    облегчая жизнь своим пользователям, они имеют такую реализацию, что остаётся
    лишь предполагать, какое количество страданий испытали их разработчики. Достаточно
    заглянуть в реализацию, увидеть забор из ifdef'ов и угловых скобок — и всё понятно.
    Нередко эти реализации делаются на грани возможностей компиляторов. workaround'ы
    банальных ошибок (или особенностей реализации языка конкретной версии конкретного
    компилятора с конкретными флагами) здорово раздувают их код. Желание поддерживать
    несколько стандартов сразу заставляет придумывать зубодробильные конструкции.
    Безусловно, простая попытка реализовать что-нибудь подобное здорово поднимает уровень
    владения языком (иногда — и самооценку). Но в какой-то момент, после многочасовой возни
    с очередной ошибкой, или непроходящим тестом, или крэшем компилятора руки опускаются,
    хочется плюнуть и бросить, ибо силы бороться иссякают.
    */

    Именно поэтому я за гомоиконность

    j123123, 21 Апреля 2019

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