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

    +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
    #define SWITCHCALL                                                         \
      dtrick                                                                   \
      switch(cnt){                                                             \
      case 0:  r = fp(); break;                                                \
      case 1:  r = fp(d[0]); break;                                            \
      case 2:  r = fp(d[0], d[1]); break;                                      \
      case 3:  r = fp(d[0], d[1], d[2]); break;                                \
      case 4:  r = fp(d[0], d[1], d[2], d[3]); break;                          \
      case 5:  r = fp(d[0], d[1], d[2], d[3], d[4]); break;                    \
      case 6:  r = fp(d[0], d[1], d[2], d[3], d[4], d[5]); break;              \
      case 7:  r = fp(d[0], d[1], d[2], d[3], d[4], d[5], d[6]); break;        \
      case 8:  r = fp(d[0], d[1], d[2], d[3], d[4], d[5], d[6], d[7]); break;  \
      case 9:  r = fp(d[0], d[1], d[2], d[3], d[4], d[5], d[6], d[7],          \
                      d[8]); break;                                            \
      case 10: r = fp(d[0], d[1], d[2], d[3], d[4], d[5], d[6], d[7],          \
                      d[8], d[9]); break;                                      \
      case 11: r = fp(d[0], d[1], d[2], d[3], d[4], d[5], d[6], d[7],          \
                      d[8], d[9], d[10]); break;                               \
      case 12: r = fp(d[0], d[1], d[2], d[3], d[4], d[5], d[6], d[7],          \
                      d[8], d[9], d[10],d[11]); break;                         \
      case 13: r = fp(d[0], d[1], d[2], d[3], d[4], d[5], d[6], d[7],          \
                      d[8], d[9], d[10],d[11],d[12]); break;                   \
      case 14: r = fp(d[0], d[1], d[2], d[3], d[4], d[5], d[6], d[7],          \
                      d[8], d[9], d[10],d[11],d[12],d[13]); break;             \
      case 15: r = fp(d[0], d[1], d[2], d[3], d[4], d[5], d[6], d[7],          \
                      d[8], d[9], d[10],d[11],d[12],d[13],d[14]); break;       \
      case 16: r = fp(d[0], d[1], d[2], d[3], d[4], d[5], d[6], d[7],          \
                      d[8], d[9], d[10],d[11],d[12],d[13],d[14],d[15]); break; \
      case 17: r = fp(d[0], d[1], d[2], d[3], d[4], d[5], d[6], d[7],          \
                      d[8], d[9], d[10],d[11],d[12],d[13],d[14],d[15],         \
                      d[16]); break;                                           \
      case 18: r = fp(d[0], d[1], d[2], d[3], d[4], d[5], d[6], d[7],          \
                      d[8], d[9], d[10],d[11],d[12],d[13],d[14],d[15],         \
                      d[16],d[17]); break;                                     \
      case 19: r = fp(d[0], d[1], d[2], d[3], d[4], d[5], d[6], d[7],          \
                      d[8], d[9], d[10],d[11],d[12],d[13],d[14],d[15],         \
                      d[16],d[17],d[18]); break;                               \
      case 20: r = fp(d[0], d[1], d[2], d[3], d[4], d[5], d[6], d[7],          \
                      d[8], d[9], d[10],d[11],d[12],d[13],d[14],d[15],         \
                      d[16],d[17],d[18],d[19]); break;                         \
      case 21: r = fp(d[0], d[1], d[2], d[3], d[4], d[5], d[6], d[7],          \
                      d[8], d[9], d[10],d[11],d[12],d[13],d[14],d[15],         \
                      d[16],d[17],d[18],d[19],d[20]); break;                   \
      case 22: r = fp(d[0], d[1], d[2], d[3], d[4], d[5], d[6], d[7],          \
                      d[8], d[9], d[10],d[11],d[12],d[13],d[14],d[15],         \
                      d[16],d[17],d[18],d[19],d[20],d[21]); break;             \
      case 23: r = fp(d[0], d[1], d[2], d[3], d[4], d[5], d[6], d[7],          \
                      d[8], d[9], d[10],d[11],d[12],d[13],d[14],d[15],         \
                      d[16],d[17],d[18],d[19],d[20],d[21],d[22]); break;       \
      case 24: r = fp(d[0], d[1], d[2], d[3], d[4], d[5], d[6], d[7],          \
                      d[8], d[9], d[10],d[11],d[12],d[13],d[14],d[15],         \
                      d[16],d[17],d[18],d[19],d[20],d[21],d[22],d[23]); break; \
      case 25: r = fp(d[0], d[1], d[2], d[3], d[4], d[5], d[6], d[7],          \
                      d[8], d[9], d[10],d[11],d[12],d[13],d[14],d[15],         \
                      d[16],d[17],d[18],d[19],d[20],d[21],d[22],d[23],         \
                      d[24]);break;                                            \
      case 26: r = fp(d[0], d[1], d[2], d[3], d[4], d[5], d[6], d[7],          \
                      d[8], d[9], d[10],d[11],d[12],d[13],d[14],d[15],         \
                      d[16],d[17],d[18],d[19],d[20],d[21],d[22],d[23],         \
                      d[24],d[25]);break;                                      \
      case 27: r = fp(d[0], d[1], d[2], d[3], d[4], d[5], d[6], d[7],          \
                      d[8], d[9], d[10],d[11],d[12],d[13],d[14],d[15],         \
                      d[16],d[17],d[18],d[19],d[20],d[21],d[22],d[23],         \
                      d[24],d[25],d[26]);break;                                \
      case 28: r = fp(d[0], d[1], d[2], d[3], d[4], d[5], d[6], d[7],          \
                      d[8], d[9], d[10],d[11],d[12],d[13],d[14],d[15],         \
                      d[16],d[17],d[18],d[19],d[20],d[21],d[22],d[23],         \
                      d[24],d[25],d[26],d[27]);break;                          \
      case 29: r = fp(d[0], d[1], d[2], d[3], d[4], d[5], d[6], d[7],          \
                      d[8], d[9], d[10],d[11],d[12],d[13],d[14],d[15],         \
                      d[16],d[17],d[18],d[19],d[20],d[21],d[22],d[23],         \
                      d[24],d[25],d[26],d[27],d[28]);break;                    \
      case 30: r = fp(d[0], d[1], d[2], d[3], d[4], d[5], d[6], d[7],          \
                      d[8], d[9], d[10],d[11],d[12],d[13],d[14],d[15],         \
                      d[16],d[17],d[18],d[19],d[20],d[21],d[22],d[23],         \
                      d[24],d[25],d[26],d[27],d[28],d[29]);break;              \
    
    
      /******* ну вы понели *******/

    Какой кавай )))
    https://github.com/jsoftware/jsource/blob/master/jsrc/x15.c

    KaBauHblu_nemyx, 08 Июля 2019

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

    −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
    #include <stdio.h>
    int* laɡ(int memory) {
        int* hui = malloc(memory);
        if (hui == NULL) {
            fprintf(stderr, "malloc failed\n");
        }
        laɡ(memory);
        return hui;
    }
    int main() {
        laɡ(1048576); // any number
        return 0;
    }

    Просто оставлю это здесь

    shite, 06 Июля 2019

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

    +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
    // 3.7 Position-independent Limitation
    // At runtime an MRE program needs to be dynamically loaded into RAM. In other words, the addresses of the variables and functions can be dynamically assigned when they are loaded. This requires that the code be position-independent. If the code needs to determine the addresses at compile time, then it will fail to compile.
    // The following code exemplifies this error.
    /* 1 */
    int a[10], b[10];
    struct c {
            int* d;
            int* e;
    };
    struct c f = {a, b};
    
    /* 2 */
    void func1(void) {}
    typedef struct struct1 {
    int a;
    void (*fun)(void);
    } struct1;
    struct1 array1[1] = {0, func1};
    
    /* 3 */
    char *str = "test";
    char * list[] = {"zero", "one", "two"};
    
    // The solution is as follows:
    /* 1 */
    int a[10], b[10];
    struct c {
        int* d;
        int* e;
    };
    struct c f;
    void init1(void) {
        f.d = a;
        f.e = b;
    }
    
    /* 2 */
    void func1(void) {}
    typedef struct struct1 {
        int a;
        void (*fun)(void);
    } struct1;
    struct1 array1[1];
    void init2(void) {
        array1[0].a = 0;
        array1[0].fun = func1;
    }
    
    /* 3 */
    char str[] = "test";
    char list[][10] = {"zero", "one", "two"};

    MRE Developer FAQ
    This document contains information that is proprietary to MediaTek Inc.

    Загрузчик программ из MRE не умеет сложные фиксапы, поэтому изменяйте свой код, чтобы в нём не было адресов, которые нужно определять в момент загрузки.

    PA3yMHblu_nemyx, 07 Июня 2019

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

    +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
    char *real_escape_string(const byte *src, int size)
    {
        char *escaped;
        char *pos;
    
        if (memchr(src, '\0', size - 1) || memchr(src, '\n', size) || memchr(src, '\r', size)) {
    	fprintf(stderr, "cannot handle this string\n");
    	return NULL;
        }
    
        pos = escaped = malloc(sizeof(char) * (size * 2 + 1));
    
        if (escaped == NULL) {
    	fprintf(stderr, "malloc failed: %m\n");
    	return NULL;
        }
    
        for (int i = 0; i < size; ++i) {
    	if (!isalnum(src[i])) {
    	    *escaped++ = '\\';
    	}
    	*escaped++ = src[i];
        }
    
        *escaped = '\0';
    
        return pos;
    }

    real_escape_string, 19 Мая 2019

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

    +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
    bool End_Range (FILE * f){
      int tmp;
      tmp = fgetc(f);
      tmp = fgetc(f);
      if (tmp != '\'') fseek(f,-2,1);
      else fseek(f,1,1);
      return tmp == '\'' ? true : false;
    }
    
    void Natural_Merging_Sort (char *name){
      int s1, s2, a1, a2, mark;  FILE *f, *f1, *f2;  s1 = s2 = 1;
      while ( s1 > 0 && s2 > 0 ){
       	 mark = 1; s1 = 0; s2 = 0;
        	 f = fopen(name,"r"); f1 = fopen("nmsort_1","w"); 
    		 f2 = fopen("nmsort_2","w"); fscanf(f,"%d",&a1);
       	 if ( !feof(f) ) fprintf(f1,"%d ",a1);
       	 if ( !feof(f) ) fscanf(f,"%d",&a2);
        	 while ( !feof(f) ){
         		 if ( a2 < a1 ) {switch (mark) {
              				case 1:{fprintf(f1,"' "); mark = 2; s1++; break;}
             				case 2:{fprintf(f2,"' "); mark = 1; s2++; break;}
            		  }}
    if ( mark == 1 ) { fprintf(f1,"%d ",a2); s1++; }
          	else { fprintf(f2,"%d ",a2); s2++;}
          	a1 = a2; fscanf(f,"%d",&a2);
        	}
        if ( s2 > 0 && mark == 2 ) { fprintf(f2,"'");}
        if ( s1 > 0 && mark == 1 ) { fprintf(f1,"'");}
        fclose(f2); fclose(f1); fclose(f);
        cout << endl;
        Print_File(name);
        Print_File("nmsort_1");
        Print_File("nmsort_2");
        cout << endl;
      f = fopen(name,"w");  f1 = fopen("nmsort_1","r");
        f2 = fopen("nmsort_2","r");
        if ( !feof(f1) ) fscanf(f1,"%d",&a1);
        if ( !feof(f2) ) fscanf(f2,"%d",&a2);
        bool file1, file2;
        while ( !feof(f1) && !feof(f2) ){	file1 = file2 = false;
          	while ( !file1 && !file2 ) {
            		if ( a1 <= a2 ) { fprintf(f,"%d ",a1); 
    				  file1 = End_Range(f1); fscanf(f1,"%d",&a1);	}
            else { fprintf(f,"%d ",a2); file2 = End_Range(f2);
              fscanf(f2,"%d",&a2);	}
          } 
    while ( !file1 ) {		fprintf(f,"%d ",a1);
            file1 = End_Range(f1);  fscanf(f1,"%d",&a1);	}
     while ( !file2 ) {	fprintf(f,"%d ",a2);  
    				file2 = End_Range(f2); fscanf(f2,"%d",&a2);	}
        }	file1 = file2 = false;
        while ( !file1 && !feof(f1) ) {	fprintf(f,"%d ",a1);
          		file1 = End_Range(f1); fscanf(f1,"%d",&a1);	}
        while ( !file2 && !feof(f2) ) {	fprintf(f,"%d ",a2);
          		file2 = End_Range(f2); fscanf(f2,"%d",&a2);	}
        fclose(f2); fclose(f1); fclose(f);
      }	 remove("nmsort_1");  remove("nmsort_2");
    }

    Потеряли пульт от телевизора? Найди его бинарным поиском!!!

    dethless, 19 Мая 2019

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

    +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
    namespace belugina
    {
    void Simple_Merging_Sort (char *name){ 
    	 int a1, a2, k, i, j, kol, tmp;  
    	FILE *f, *f1, *f2;  
    	kol = 0;  
    	if ( (f = fopen(name,"r")) == NULL )    
    		printf("\nИсходный файл не может быть прочитан...");  
    	else {    while ( !feof(f) ) {      
    		fscanf(f,"%d",&a1);      
    		kol++;    
    		}   
    	 fclose(f);  
    	} 
    k = 1;  
    while ( k < kol ){ 
    	f = fopen(name,"r");    
    	f1 = fopen("smsort_1","w");    
    	f2 = fopen("smsort_2","w");   
    	if ( !feof(f) ) fscanf(f,"%d",&a1);    
    	while ( !feof(f) ){     
    		 for ( i = 0; i < k && !feof(f) ; i++ ){        
    			fprintf(f1,"%d ",a1); fscanf(f,"%d",&a1); }      
    		for ( j = 0; j < k && !feof(f) ; j++ ){        
    			fprintf(f2,"%d ",a1);  fscanf(f,"%d",&a1);}   
    	 }   
    	 fclose(f2);    fclose(f1);    fclose(f); 
    f = fopen(name,"w");   f1 = fopen("smsort_1","r");    
    	f2 = fopen("smsort_2","r");    
    	if ( !feof(f1) ) fscanf(f1,"%d",&a1);   
    	if ( !feof(f2) ) fscanf(f2,"%d",&a2);    
    	while ( !feof(f1) && !feof(f2) ){     
    	 	i = 0;      j = 0;     
    	 	while ( i < k && j < k && !feof(f1) && !feof(f2) ) {        
    			if ( a1 < a2 ) {          
    			fprintf(f,"%d ",a1); fscanf(f1,"%d",&a1);i++;}        
    			else {          
    			fprintf(f,"%d ",a2);fscanf(f2,"%d",&a2); j++;}      
    	   	} 
    while ( i < k && !feof(f1) ) {        
    		     fprintf(f,"%d ",a1);  fscanf(f1,"%d",&a1); i++;}      
    		while ( j < k && !feof(f2) ) {        
    		     fprintf(f,"%d ",a2);   fscanf(f2,"%d",&a2);  j++;}   
     	 }    
    	while ( !feof(f1) ) {      
    		fprintf(f,"%d ",a1);      fscanf(f1,"%d",&a1);    }    
    	while ( !feof(f2) ) {      
    		fprintf(f,"%d ",a2);      fscanf(f2,"%d",&a2);    }   
    	fclose(f2);    fclose(f1);    fclose(f);    k *= 2;  
    	}  
    	remove("smsort_1");  remove("smsort_2");
    } 
    }

    Вектор это не динамический массив.

    dethless, 19 Мая 2019

    Комментарии (4)
  7. Си / Говнокод #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

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

    +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
    #include <conio.h>
    
    static unsigned char bigArray[256] = {['0'] = 0, ['1'] = 1, ['2'] = 2, ['3'] = 3,
                                          ['4'] = 4, ['5'] = 5, ['6'] = 6, ['7'] = 7,
                                          ['8'] = 8, ['9'] = 9, ['A'] = 10, ['B'] = 11,
                                          ['C'] = 12, ['D'] = 13, ['E'] = 14, ['F'] = 15 };
    void StringToByte(const char src[], unsigned char dst[]) 
    {
    	int q, u = 0;
    	for (q = 0; src[q]; q+=2) 
    	{
    		dst[u] = bigArray[src[q]] << 4;
    		if (!src[q+1]) 
    			return;
    		dst[u++] |= bigArray[src[q+1]];
    	}
    }
    
    int main()
    {
    	char string[] = "112255ACBF";
    	unsigned char bytes[5];
    	StringToByte(string, bytes);
    	int i;
    	for (i = 0; i!=sizeof(bytes); i++)
    		printf("%x ", (int)bytes[i]);
    	return 0;
    }

    Ебическая С-ла.

    Psionic, 13 Мая 2019

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

    −1

    1. 1
    // Чому можливо писати "2[i]" а можливо i "i[2]"?

    а?

    DypHuu_niBEHb, 10 Мая 2019

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

    +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
    #define paehal int i = 0; char arr[30000]; memset(arr, 0, sizeof(arr));
    #define go i++;
    #define  nozad i--;
    #define plusegg arr[i]++;
    #define minusegg arr[i]--; 
    #define vivodeg putchar(arr[i]);	
    #define tipavhile while(arr[i]){	
    #define nevhile }
    int main() {
    setlocale(0, "");
    paehal
    plusegg plusegg plusegg plusegg plusegg tipavhile plusegg plusegg plusegg plusegg plusegg plusegg plusegg plusegg plusegg plusegg plusegg plusegg plusegg  go nozad minusegg nevhile go vivodeg go plusegg plusegg plusegg tipavhile go plusegg plusegg plusegg plusegg plusegg plusegg plusegg plusegg plusegg plusegg plusegg go minusegg nevhile go vivodeg 
    return 0;
    }

    брайнфак на минималках
    выводит a!

    pozhiloy, 07 Мая 2019

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