Си — Говнокод.ру

Си / Говнокод #27255

0

01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

#include <stdio.h>
#include <stdlib.h>
#include <inttypes.h>

int main(void)
{
  uint32_t uint32max = UINT32_MAX;
  int32_t int32_minus_one = -1;
  printf("uint32_max = %" PRIu32 "\n", uint32max);
  printf("int32_minus_one = %" PRIi32 "\n", int32_minus_one);
  if (uint32max > int32_minus_one)
  {
    puts("uint32max > int32_minus_one");
  }
  else if (uint32max < int32_minus_one)
  {
    puts("uint32max < int32_minus_one");
  }
  else
  {
    puts("uint32max == int32_minus_one");
  }
  return EXIT_SUCCESS;
}

Почему в Си нет особого правила при сравнении signed и unsigned типов, ну типа если значение в signed типе отрицательно, то он полюбасу будет меньше любого unsigned значения? А то говно какое-то.

(нет, я понимаю почему так происходит, но все равно говно)

j123123, 15 Февраля 2021

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

Си / Говнокод #27240

0

01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90

// https://github.com/ARMmbed/mbedtls/blob/a0832d47f7eb859f75301ae321be5dea4ccb17f3/library/aes.c#L128

/*
 * Forward tables
 */
#define FT \
\
    V(A5,63,63,C6), V(84,7C,7C,F8), V(99,77,77,EE), V(8D,7B,7B,F6), \
    V(0D,F2,F2,FF), V(BD,6B,6B,D6), V(B1,6F,6F,DE), V(54,C5,C5,91), \
    V(50,30,30,60), V(03,01,01,02), V(A9,67,67,CE), V(7D,2B,2B,56), \
    V(19,FE,FE,E7), V(62,D7,D7,B5), V(E6,AB,AB,4D), V(9A,76,76,EC), \
    V(45,CA,CA,8F), V(9D,82,82,1F), V(40,C9,C9,89), V(87,7D,7D,FA), \
    V(15,FA,FA,EF), V(EB,59,59,B2), V(C9,47,47,8E), V(0B,F0,F0,FB), \
    V(EC,AD,AD,41), V(67,D4,D4,B3), V(FD,A2,A2,5F), V(EA,AF,AF,45), \
    V(BF,9C,9C,23), V(F7,A4,A4,53), V(96,72,72,E4), V(5B,C0,C0,9B), \
    V(C2,B7,B7,75), V(1C,FD,FD,E1), V(AE,93,93,3D), V(6A,26,26,4C), \
    V(5A,36,36,6C), V(41,3F,3F,7E), V(02,F7,F7,F5), V(4F,CC,CC,83), \
    V(5C,34,34,68), V(F4,A5,A5,51), V(34,E5,E5,D1), V(08,F1,F1,F9), \
    V(93,71,71,E2), V(73,D8,D8,AB), V(53,31,31,62), V(3F,15,15,2A), \
    V(0C,04,04,08), V(52,C7,C7,95), V(65,23,23,46), V(5E,C3,C3,9D), \
    V(28,18,18,30), V(A1,96,96,37), V(0F,05,05,0A), V(B5,9A,9A,2F), \
    V(09,07,07,0E), V(36,12,12,24), V(9B,80,80,1B), V(3D,E2,E2,DF), \
    V(26,EB,EB,CD), V(69,27,27,4E), V(CD,B2,B2,7F), V(9F,75,75,EA), \
    V(1B,09,09,12), V(9E,83,83,1D), V(74,2C,2C,58), V(2E,1A,1A,34), \
    V(2D,1B,1B,36), V(B2,6E,6E,DC), V(EE,5A,5A,B4), V(FB,A0,A0,5B), \
    V(F6,52,52,A4), V(4D,3B,3B,76), V(61,D6,D6,B7), V(CE,B3,B3,7D), \
    V(7B,29,29,52), V(3E,E3,E3,DD), V(71,2F,2F,5E), V(97,84,84,13), \
    V(F5,53,53,A6), V(68,D1,D1,B9), V(00,00,00,00), V(2C,ED,ED,C1), \
    V(60,20,20,40), V(1F,FC,FC,E3), V(C8,B1,B1,79), V(ED,5B,5B,B6), \
    V(BE,6A,6A,D4), V(46,CB,CB,8D), V(D9,BE,BE,67), V(4B,39,39,72), \
    V(DE,4A,4A,94), V(D4,4C,4C,98), V(E8,58,58,B0), V(4A,CF,CF,85), \
    V(6B,D0,D0,BB), V(2A,EF,EF,C5), V(E5,AA,AA,4F), V(16,FB,FB,ED), \
    V(C5,43,43,86), V(D7,4D,4D,9A), V(55,33,33,66), V(94,85,85,11), \
    V(CF,45,45,8A), V(10,F9,F9,E9), V(06,02,02,04), V(81,7F,7F,FE), \
    V(F0,50,50,A0), V(44,3C,3C,78), V(BA,9F,9F,25), V(E3,A8,A8,4B), \
    V(F3,51,51,A2), V(FE,A3,A3,5D), V(C0,40,40,80), V(8A,8F,8F,05), \
    V(AD,92,92,3F), V(BC,9D,9D,21), V(48,38,38,70), V(04,F5,F5,F1), \
    V(DF,BC,BC,63), V(C1,B6,B6,77), V(75,DA,DA,AF), V(63,21,21,42), \
    V(30,10,10,20), V(1A,FF,FF,E5), V(0E,F3,F3,FD), V(6D,D2,D2,BF), \
    V(4C,CD,CD,81), V(14,0C,0C,18), V(35,13,13,26), V(2F,EC,EC,C3), \
    V(E1,5F,5F,BE), V(A2,97,97,35), V(CC,44,44,88), V(39,17,17,2E), \
    V(57,C4,C4,93), V(F2,A7,A7,55), V(82,7E,7E,FC), V(47,3D,3D,7A), \
    V(AC,64,64,C8), V(E7,5D,5D,BA), V(2B,19,19,32), V(95,73,73,E6), \
    V(A0,60,60,C0), V(98,81,81,19), V(D1,4F,4F,9E), V(7F,DC,DC,A3), \
    V(66,22,22,44), V(7E,2A,2A,54), V(AB,90,90,3B), V(83,88,88,0B), \
    V(CA,46,46,8C), V(29,EE,EE,C7), V(D3,B8,B8,6B), V(3C,14,14,28), \
    V(79,DE,DE,A7), V(E2,5E,5E,BC), V(1D,0B,0B,16), V(76,DB,DB,AD), \
    V(3B,E0,E0,DB), V(56,32,32,64), V(4E,3A,3A,74), V(1E,0A,0A,14), \
    V(DB,49,49,92), V(0A,06,06,0C), V(6C,24,24,48), V(E4,5C,5C,B8), \
    V(5D,C2,C2,9F), V(6E,D3,D3,BD), V(EF,AC,AC,43), V(A6,62,62,C4), \
    V(A8,91,91,39), V(A4,95,95,31), V(37,E4,E4,D3), V(8B,79,79,F2), \
    V(32,E7,E7,D5), V(43,C8,C8,8B), V(59,37,37,6E), V(B7,6D,6D,DA), \
    V(8C,8D,8D,01), V(64,D5,D5,B1), V(D2,4E,4E,9C), V(E0,A9,A9,49), \
    V(B4,6C,6C,D8), V(FA,56,56,AC), V(07,F4,F4,F3), V(25,EA,EA,CF), \
    V(AF,65,65,CA), V(8E,7A,7A,F4), V(E9,AE,AE,47), V(18,08,08,10), \
    V(D5,BA,BA,6F), V(88,78,78,F0), V(6F,25,25,4A), V(72,2E,2E,5C), \
    V(24,1C,1C,38), V(F1,A6,A6,57), V(C7,B4,B4,73), V(51,C6,C6,97), \
    V(23,E8,E8,CB), V(7C,DD,DD,A1), V(9C,74,74,E8), V(21,1F,1F,3E), \
    V(DD,4B,4B,96), V(DC,BD,BD,61), V(86,8B,8B,0D), V(85,8A,8A,0F), \
    V(90,70,70,E0), V(42,3E,3E,7C), V(C4,B5,B5,71), V(AA,66,66,CC), \
    V(D8,48,48,90), V(05,03,03,06), V(01,F6,F6,F7), V(12,0E,0E,1C), \
    V(A3,61,61,C2), V(5F,35,35,6A), V(F9,57,57,AE), V(D0,B9,B9,69), \
    V(91,86,86,17), V(58,C1,C1,99), V(27,1D,1D,3A), V(B9,9E,9E,27), \
    V(38,E1,E1,D9), V(13,F8,F8,EB), V(B3,98,98,2B), V(33,11,11,22), \
    V(BB,69,69,D2), V(70,D9,D9,A9), V(89,8E,8E,07), V(A7,94,94,33), \
    V(B6,9B,9B,2D), V(22,1E,1E,3C), V(92,87,87,15), V(20,E9,E9,C9), \
    V(49,CE,CE,87), V(FF,55,55,AA), V(78,28,28,50), V(7A,DF,DF,A5), \
    V(8F,8C,8C,03), V(F8,A1,A1,59), V(80,89,89,09), V(17,0D,0D,1A), \
    V(DA,BF,BF,65), V(31,E6,E6,D7), V(C6,42,42,84), V(B8,68,68,D0), \
    V(C3,41,41,82), V(B0,99,99,29), V(77,2D,2D,5A), V(11,0F,0F,1E), \
    V(CB,B0,B0,7B), V(FC,54,54,A8), V(D6,BB,BB,6D), V(3A,16,16,2C)


#define V(a,b,c,d) 0x##a##b##c##d
static const uint32_t FT0[256] = { FT };
#undef V

#if !defined(MBEDTLS_AES_FEWER_TABLES)

#define V(a,b,c,d) 0x##b##c##d##a
static const uint32_t FT1[256] = { FT };
#undef V

#define V(a,b,c,d) 0x##c##d##a##b
static const uint32_t FT2[256] = { FT };
#undef V

#define V(a,b,c,d) 0x##d##a##b##c
static const uint32_t FT3[256] = { FT };
#undef V

Какая генерация )))
Крестобляди б наверное тут какими-то констэкспрами делали нужные кобенации битиков. А тут прость через перегрузку переопределение дефайна можно по-разному байтики сшивать.

j123123, 07 Февраля 2021

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

Си / Говнокод #27230

0

01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79

function main()
{
	assert(false, "defl0");
}

// получаетм MLIR tsc.exe --emit=mlir C:\temp\2.ts

module  {
  func @main() {
    %false = constant false
    typescript.assert %false, "defl0"
    return
  }
}

// или MLIR-LLVM

module  {
  llvm.mlir.global internal constant @f_7029868395233414505("C:\\temp\\2.ts\00")
  llvm.mlir.global internal constant @m_964876063036005986("defl0\00")
  llvm.func @_assert(!llvm.ptr<i8>, !llvm.ptr<i8>, i32)
  llvm.func @main() {
    %0 = llvm.mlir.constant(false) : i1
    llvm.cond_br %0, ^bb1, ^bb2
  ^bb1:  // pred: ^bb0
    llvm.return
  ^bb2:  // pred: ^bb0
    %1 = llvm.mlir.addressof @m_964876063036005986 : !llvm.ptr<array<6 x i8>>
    %2 = llvm.mlir.constant(0 : index) : i64
    %3 = llvm.getelementptr %1[%2, %2] : (!llvm.ptr<array<6 x i8>>, i64, i64) -> !llvm.ptr<i8>
    %4 = llvm.mlir.addressof @f_7029868395233414505 : !llvm.ptr<array<13 x i8>>
    %5 = llvm.mlir.constant(0 : index) : i64
    %6 = llvm.getelementptr %4[%5, %5] : (!llvm.ptr<array<13 x i8>>, i64, i64) -> !llvm.ptr<i8>
    %7 = llvm.mlir.constant(5 : i32) : i32
    llvm.call @_assert(%3, %6, %7) : (!llvm.ptr<i8>, !llvm.ptr<i8>, i32) -> ()
    llvm.unreachable
  }
}

// переводим в LLVM mlir-translate.exe --mlir-to-llvmir -o=out.il 1.mlir и получаем полный абзец

; ModuleID = 'LLVMDialectModule'
source_filename = "LLVMDialectModule"

@m_15759024501200700639 = internal constant [6 x i8] c"defl2\00"
@f_7029868395233414505 = internal constant [13 x i8] c"C:\\temp\\2.ts\00"
@m_9918845950589312633 = internal constant [6 x i8] c"defl0\00"

declare i8* @malloc(i64)

declare void @free(i8*)

declare void @_assert(i8*, i8*, i32)

define void @main() !dbg !3 {
  br i1 false, label %1, label %3, !dbg !7

1:                                                ; preds = %0
  br i1 false, label %2, label %4, !dbg !9

2:                                                ; preds = %1
  ret void, !dbg !10

3:                                                ; preds = %0
  call void @_assert(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @m_9918845950589312633, i64 0, i64 0), i8* getelementptr inbounds ([13 x i8], [13 x i8]* @f_7029868395233414505, i64 0, i64 0), i32 5), !dbg !11
  unreachable, !dbg !12

4:                                                ; preds = %1
  call void @_assert(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @m_15759024501200700639, i64 0, i64 0), i8* getelementptr inbounds ([13 x i8], [13 x i8]* @f_7029868395233414505, i64 0, i64 0), i32 12), !dbg !13
  unreachable, !dbg !14
}

// компилим это говно и получаем EXE
// llc.exe --filetype=obj -o=out.o out.il
// lld.exe -flavor link out.o "libcmt.lib" "libvcruntime.lib" "kernel32.lib" "libucrt.lib" "uuid.lib" 
// запускаем и вуаля

// Output:
// Assertion failed: defl0, file C:\temp\2.ts, line 5

продолжаем говнокодить. что получается из одной строчки после компиляции когда в TypeScript (компайлером)

ну все сказанно в говнокоде

ASD_77, 02 Февраля 2021

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

Си / Говнокод #27227

0

1
2
3
4
5

char* to_str(int i) {
    char* s = malloc(12);
    sprintf(s, "%d", i);
    return s;
}

Как в сишке без RAII принято жить? Пиздец какой-то. Буфер в функцию передавать?

Что мешает завезти RAII в сишку?

3_dar, 30 Января 2021

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

Си / Говнокод #27215

−1

01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59

includelib  C:\Irvine\User32.Lib
includelib  C:\Irvine\Kernel32.Lib
includelib  D:\masm32\lib\Irvine32.lib
include     \masm32\include\Irvine32.inc

.data

data_1 dword  45

data_2 dword 29

msg byte ?

.code
main PROC
xor ebx,  ebx
xor eax,  eax
xor edx,  edx
xor esi,  esi

mov cl ,31
mov eax, data_1
mov esi , data_2


lm:

shl esi,   1
jnc one
cmp msg, 1

je two
shl eax,   cl

mov   msg, 1
mov ebx, data_1
jmp one

two:

shl ebx, cl
mov   msg, 0
add eax, ebx
add edx , eax
mov eax, data_1


one:

loop lm

mov eax , edx

call WriteInt
Call CrLf
	
	exit
main ENDP
END main

Hey, Mr. Tambourine Man, play a song for me
I'm not sleepy and there is no place I'm going to
Hey, Mr. Tambourine Man, play a song for me
In the jingle jangle morning I'll come following you
Though I know that evening's empire has returned into sand
Vanished from my hand
Left me blindly here to stand, but still not sleeping
My weariness amazes me, I'm branded on my feet
I have no one to meet
And the ancient empty street's too dead for dreaming
Hey, Mr. Tambourine Man, play a song for me
I'm not sleepy and there is no place I'm going to
Hey, Mr. Tambourine Man, play a song for me
In the jingle jangle morning I'll come following you
Take me on a trip upon your magic swirling ship
My senses have been stripped
My hands can't feel to grip
My toes too numb to step
Wait only for my boot heels to be wandering
I'm ready to go anywhere, I'm ready for to fade
Into my own parade
Cast your dancing spell my way, I promise to go under it
Hey, Mr. Tambourine Man, play a song for me
I'm not sleepy and there is no place I'm going to
Hey, Mr. Tambourine Man, play a song for me
In the jingle jangle morning I'll come following you

Madhouse_camomile, 14 Января 2021

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

Си / Говнокод #27199

−3

001
002
003
004
005
006
007
008
009
010
011
012
013
014
015
016
017
018
019
020
021
022
023
024
025
026
027
028
029
030
031
032
033
034
035
036
037
038
039
040
041
042
043
044
045
046
047
048
049
050
051
052
053
054
055
056
057
058
059
060
061
062
063
064
065
066
067
068
069
070
071
072
073
074
075
076
077
078
079
080
081
082
083
084
085
086
087
088
089
090
091
092
093
094
095
096
097
098
099
100

int hlp_fix(char data[]  , char dump_alpha[] ){
int run = 0;
char prev = '0';
int count_bracket = 0 ;
puts(dump_alpha);
	
if(my_isdigit(data[0]) || my_isalpha(data[0])    ){
					 prev = data[0];
					}
	else if (data[0] == '('){
			count_bracket++;
			 prev = data[0];
	}
 			else{
				  
					puts("!!!  first error  !!!");
				  	exit(1);
				  }

for(run = 1;data[run] != '\0' ;run++){
	
	
	if ( data[run + 1]    == '\0'  &&  isOperator(prev )           ){
					
					puts("!!! error  isOperator  !!!");
				  	exit(1);
			}

	
	if(isgraph(data[run] )){
		
		if( secure_1(data[run], dump_alpha )  ) { 
		  printf("!!! error  this no list = %c !!!",  data[run] );
			exit(1);
		}
		
		if(prev == '.' ){
			
			if( data[run  - 1 ]   == '.' && my_isdigit(data[run])      )   {
						 prev = data[run];
				}
		
		 else{
				  	
					puts(" !!! error point !!!");
				  	exit(1);
				  }
			}
		
			else	if(my_isdigit(prev)  ){
				
			
			if(  data[run] == ')' )   {
					 	 prev = data[run];
					 	--count_bracket;
					 }
				
			else	if(	 (	my_isdigit(data[ run - 1  ])       	||	data[run - 1 ] == '.' || 
					
					isOperator(data[run]) )    ){
					 prev = data[run];
					
			}
					 
			else{
				  puts("error  isdigit");
				  	exit(1);
				  }
				}
		
			else	if(isOperator(prev)){
			
				if( (my_isdigit(data[run])  || my_isalpha(data[run] )       )   ){
						 prev = data[run];
				}
					else if ( data[run] == '('  ){
							 prev = data[run];
							 count_bracket++;
					}
					
			else{
				  	
					puts("error  isOperator");
				  	exit(1);
				  }
				}
			
			else	if(prev == '(' ){
			
				if( (my_isdigit(data[run] )  || my_isalpha(data[run] )  ) ){
					 prev = data[run];
				
				}
				else if ( data[run] == '('){
					 count_bracket++;
					 prev = data[run];
				}
				
				
				else{

Ни что так не вдохновляет на бейсджампинг без парашюта как "отлов ошибок" который не работает ))))
https://ideone.com/rjrwMQ

Oh-my-God-my-leg, 07 Января 2021

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

Си / Говнокод #27191

0

01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18

void s_sort(int *a, size_t sz)
{
  if ((sz == 0) || (sz == 1))
  {
    return;
  }
  if (sz  == 2)
  {
    int a_max = a[0] > a[1] ? a[0] : a[1];
    int a_min = a[0] > a[1] ? a[1] : a[0];
    a[0] = a_min;
    a[1] = a_max;
    return;
  }
  s_sort(a, sz - 1);
  s_sort(a + 1, sz - 1);
  s_sort(a, sz - 1);
}

Крайне тупая по своей сути рекурсивная сортировка. Есть ли у нее название?

Вряд ли она имеет какое-то практическое применение именно как сортировка, но зато можно ее переписать на какой-нибудь Coq и об нее доказывать другие сортировки. Типа если какая-то там другая сортировка на всех возможных входных массивах выдает то же, что и выдает вот эта сортировка, то сортировка правильная.

j123123, 03 Января 2021

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

Си / Говнокод #27185

+2

01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

chek_LD(void)
{
	LOCK_DETECT = read();
	if (LOCK_DETECT == SAVE_LOCK_DETECT)
	{
		return;
	}
	if (LOCK_DETECT == 0)
	{
		LOCK_DETECT = read();
		if (LOCK_DETECT == 0)
		{
			if (LOCK_DETECT != SAVE_LOCK_DETECT)
			{
				SAVE_LOCK_DETECT = 0;
			}
		}
	}
	else
	{
		delay_us(5);
		LOCK_DETECT = read();
		if (LOCK_DETECT == 1)
		{
			if (LOCK_DETECT != SAVE_LOCK_DETECT)
			{
				SAVE_LOCK_DETECT = 1;
			}
		}
	}
	return;
}

пришел на легаси проект. обожаю глобальные переменные на весь проект. еще больше обожаю логику)

viteo, 29 Декабря 2020

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

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

+1

1

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

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

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

j123123, 11 Ноября 2020

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

Си / Говнокод #27067

−1

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

Говнокод: по колено в коде.