1. Си / Говнокод #27103

    +1

    1. 1
    #define LEAP_YEAR_OR_NOT(year)( ( year % 4 ) ? ( 0 ) : ( 1 ) )

    Тот кто это писал, видимо рассуждал примерно так:

    - В 2100 году это конечно забагует, но это будет уже не моя проблема.

    j123123, 11 Ноября 2020

    Комментарии (41)
  2. Си / Говнокод #27067

    −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
    98. 98
    99. 99
    jsonObj_t *__jsonLoad(const char *_str_json, size_t _len_str_json, jsonErr_t *_error) {
    	jsonObj_t *obj_json = NULL;
    	jsonObj_t *obj_json_children = NULL;	// Тут будет зиждется объект
    	jsonObj_t *obj_json_tmp = NULL;	// Тут будет зиждется объект
    
    	size_t index_in_json_str = 0;
    	size_t len_key = 0;				// Размер извлекаемого ключа
    	size_t len_value = 0;			// Размер извлекаемого значения
    	size_t count_hooks = 0;			// Счётчик скобок, чтобы игнорировать их при чтении объекта
    
    	uint8_t flag_found_separator = 0;		// Флаг чтения ключа
    	uint8_t flag_found_start = 0;	// Флаг начало JSON-объекта
    	// uint8_t flag_found_end = 0;		// Флаг окончания JSON-объекта
    	uint8_t flag_read_key = 0;		// Флаг чтения ключа
    	uint8_t flag_read_force_read = 0;	// Флаг-костыль для ситуаций, когда число последнее в массиве
    	uint8_t flag_read_value = 0;	// Флаг чтения значения
    	uint8_t flag_read_array = 0;	// Флаг чтения и обработки массива
    	uint8_t flag_want_value = 0;	// Флаг ожидания значения
    									// 	(выставляется после успешно прочитанного ключа)
    
    	jsonErr_t json_err = JSON_OK;
    
    	int res = 0;
    
    	jsonValueType_t type_expected_value = JSON_VALUE_NONE;	// Ожидаемы тип считываемого значения
    
    	char chr_open = '\0';
    	char chr_close = '\0';
    
    	const char *ptr_key = NULL;		// Указатель на начало извлекаемого ключа
    	const char *ptr_value = NULL;	// Указатель на начало извлекаемого значения
    
    	if (_error != NULL)
    	{
    		*_error = JSON_OK;
    	}
    
    	for (index_in_json_str = 0; index_in_json_str < _len_str_json; ++index_in_json_str)
    	{
    		// Если начало JSON-объекта не найдено, то пропускать
    		if (flag_found_start == 0)
    		{
    			// Поиск начала JSON-объекта
    			if (_str_json[index_in_json_str] == '{')
    			{
    				flag_found_start = 1;
    			}
    
    			if (_str_json[index_in_json_str] == '[')
    			{
    				flag_found_start = 1;
    				flag_read_array = 1;
    				flag_want_value = 1;
    				flag_found_separator = 1;	// Сразу после знака "[" ожидается значение
    			}
    
    			continue;
    		}
    
    		// Обработка ключа 
    		if ((flag_read_key == 0) &&\
    			(flag_read_value == 0) &&\
    			(flag_want_value == 0) &&\
    			(flag_read_array == 0))
    		{
    			if (((_str_json[index_in_json_str] == '\"') || (_str_json[index_in_json_str] == '\'')))
    			{
    				chr_close = _str_json[index_in_json_str];
    				flag_read_key = 1;	// Флаг начало чтения ключа
    
    				if ((index_in_json_str + 1) != _len_str_json)
    				{
    					ptr_value = (const char *)(_str_json + index_in_json_str + 1);
    					len_value = 1;
    				}
    				else
    				{
    					if (_error != NULL)
    					{
    						*_error = JSON_ERR_BAD_JSON;
    					}
    
    					jsonFree(obj_json);
    					return (NULL);
    				}
    			}
    
    			continue;
    		}
    
    		// Обработка значения
    		if ((flag_want_value == 1) && (flag_read_value == 0))
    		{
    			// Поиск разделителя ключа и значения
    			if (flag_found_separator == 0)
    			{
    				if ((_str_json[index_in_json_str] == ']') && (flag_read_array == 1))
    				{
    					// flag_found_end = 1;

    Либа продакшеновая, эта функция около 470 строк кода, всё не вместилось... Нет, индусов у нас нет, как и ответственного за качество кода тоже) и да это ещё один парсер. Опирается ли он на спецификацию JSON? Нет конечно же, боже упаси, зачем? Зато она прекрасно понимает TRUE как true и FALSE как false, а ваши жалкие либы такого не могут

    viktorokh96, 28 Октября 2020

    Комментарии (32)
  3. Си / Говнокод #27042

    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
    double func_atof(char *p){
    
    	double	 integer = 0.0, div = 1.0 , fract = 0.0 , sign = 1.0;
            
            if(   *p == 45  ){
                      sign = -1.0, *p++ ; 
              }
    	
            while ( isdigit(*p)  ) { 
    	         
                integer = ( *p++ )  +  (10.0   *   integer)  -  48.0 ; 
    	}
    	
             if(*p == 46  ){
    
    	            (*p++ ) ;
    	
            while (  isdigit(*p) )  {
    		
                 fract = ( *p++ )  +  (10.0   *   fract)  -  48.0  ; 
    		
                 div *= 10;		
    
    		}
    
        }
      
    return    (integer  +   fract  / div )  * sign    ;
    }

    Наше всё Гайвер и Сорокин

    Oh-my-God-my-leg, 19 Октября 2020

    Комментарии (14)
  4. Си / Говнокод #26993

    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
    #include <stdio.h>
    
    int main()
    {
        goto a;
        h: printf("W"); goto i;
        g: printf(" "); goto h;
        m: printf("!"); goto n;
        i: printf("o"); goto j;
        n: printf("\n"); goto end;
        b: printf("e"); goto c;
        e: printf("o"); goto f;
        j: printf("r"); goto k;
        d: printf("l"); goto e;
        f: printf(","); goto g;
        a: printf("H"); goto b;
        k: printf("l"); goto l;
        l: printf("d"); goto m;
        c: printf("l"); goto d;
        end: ;
        
        return 0;
    }

    GDMaster, 01 Октября 2020

    Комментарии (39)
  5. Си / Говнокод #26982

    +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
    /* https://habr.com/ru/company/piter/blog/491996/
    
    Пусть в Python такая штука и называется генератором, в языке C++ она
    называлась бы корутиной. Пример взят с этого сайта: https://masnun.com/2015/11/13/python-generators-coroutines-native-coroutines-and-async-await.html
    
    def generate_nums():
         num = 0
         while True:
              yield num
              num = num + 1	
    
    nums = generate_nums()
    	
    for x in nums:
         print(x)
    	
         if x > 9:
    */
    
    #include <stdio.h>
    #include <stdlib.h>
    #include <stdint.h>
    #include <stdbool.h>
    
    #define START 0
    #define YIELD 1
    
    typedef struct 
    {
      uint8_t jmpto;
      int num;
    } coroutine_state;
    
    
    int generate_nums(coroutine_state *state)
    {
      switch(state->jmpto)
      {
        case START: break;
        case YIELD: goto yield;
      }
      while (true)
      {
        state->jmpto = YIELD; return state->num; yield: // какая питушня
    
        state->num = state->num + 1;
      }
    }
    
    
    
    
    int main(void)
    {
      int x;
      coroutine_state st = {START, 0};
      while(true)
      {
        x = generate_nums(&st);
        printf("%d\n", x);
    
        if (x > 9)
        {
          break;
        }
      }
      return EXIT_SUCCESS;
    }

    Попробовал переписать эту ко-ко-корутину c питуха на Си - получилась какая-то херня нечитаемая. что еще раз доказывает, что корутины нахуй не нужны

    К тому же в крестопарашном говне они требуют хип, а это нахуй не нужно на самом-то деле.

    j123123, 28 Сентября 2020

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

    +4

    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
    static int parse_num(const char *s, size_t *out) {
        if (s == NULL || *s == '\0')
            return -1;
    
        char *end = 0;
        errno = 0;
        uint64_t num = strtoull(s, &end, 0);
        if (errno != 0)
            return -1;
    
        if (*end != '\0')
            return -1;
    
        if (num > SIZE_MAX)
            return -1;
    
        *out = (size_t)num;
        return 0;
    }

    Какие же всё-таки удобные функции в стандартной няшколибе.

    bormand, 24 Сентября 2020

    Комментарии (76)
  7. Си / Говнокод #26972

    0

    1. 1
    2. 2
    3. 3
    4. 4
    5. 5
    6. 6
    #include <stdlib.h>
    
    void main()
    {
        a: ; malloc(1); goto a;
    }

    GDMaster, 23 Сентября 2020

    Комментарии (17)
  8. Си / Говнокод #26951

    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
    #include <stdio.h>
    #include <csptr/smart_ptr.h>
    #include <csptr/array.h>
    
    void print_int(void *ptr, void *meta) {
        (void) meta;
        // ptr points to the current element
        // meta points to the array metadata (global to the array), if any.
        printf("%d\n", *(int*) ptr);
    }
    
    int main(void) {
        // Destructors for array types are run on every element of the
        // array before destruction.
        smart int *ints = unique_ptr(int[5], {5, 4, 3, 2, 1}, print_int);
        // ints == {5, 4, 3, 2, 1}
    
        // Smart arrays are length-aware
        for (size_t i = 0; i < array_length(ints); ++i) {
            ints[i] = i + 1;
        }
        // ints == {1, 2, 3, 4, 5}
    
        return 0;
    }

    Allocating a smart array and printing its contents before destruction.

    C Smart Pointers

    What this is
    This project is an attempt to bring smart pointer constructs to the (GNU) C programming language.

    Features: unique_ptr, shared_ptr macros, and smart type attribute

    https://github.com/Snaipe/libcsptr

    3.14159265, 15 Сентября 2020

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

    +6

    1. 1
    2. 2
    #define add(x, y) &((void*)x)[y];
    #define mul(x, y) (sizeof (char[x][y]))

    из свитера

    3.14159265, 10 Сентября 2020

    Комментарии (337)
  10. Си / Говнокод #26918

    +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
    #include <stdio.h>
    #include <string.h>
    #include "s_gets.h"
    #define SIZE 30
    
    void revers(char *);
    
    int main(){
        char str[SIZE];
        s_gets(str, SIZE);
        revers(str);
        puts(str);
        return 0;
    }
    
    void revers(char * str){
        int size_ = strlen(str) - 1;
        char tmp;
        for(int i = size_; i >= 0; i--){
            tmp = str[i];
            str[i] = str[size_ - i];
            str[size_ - i] = tmp;
        }
    }

    https://ru.stackoverflow.com/questions/1173617/Изменения-строки-в-функции

    > Собственно задание заключается в написании функции, которая заменяет содержимое указанной строки этой же строкой, но с обратным порядком следования символов. Почему строка не переворачивается?


    Какой багор )))

    OCETuHCKuu_nemyx, 03 Сентября 2020

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