-
−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
-
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
-
+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
-
+1
- 1
#define LEAP_YEAR_OR_NOT(year)( ( year % 4 ) ? ( 0 ) : ( 1 ) )
Тот кто это писал, видимо рассуждал примерно так:
- В 2100 году это конечно забагует, но это будет уже не моя проблема.
j123123,
11 Ноября 2020
-
−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
-
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
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
-
0
- 01
- 02
- 03
- 04
- 05
- 06
- 07
- 08
- 09
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 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
-
+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
- 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
/* 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
-
+4
- 01
- 02
- 03
- 04
- 05
- 06
- 07
- 08
- 09
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 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
-
0
- 1
- 2
- 3
- 4
- 5
- 6
#include <stdlib.h>
void main()
{
a: ; malloc(1); goto a;
}
GDMaster,
23 Сентября 2020
Follow us!