1
2
3
4
5
6
7
8
9
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
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
|
#include "str.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <stddef.h>
#include <stdbool.h>
#include <stdarg.h>
#include <ctype.h>
char** str_split(char *str, char delim) {
char **ret;
if (str == NULL) return NULL;
if (*str == '\n') {
ret = malloc(sizeof(char*));
*ret = NULL;
return ret;
}
int count = 0;
char *begin = str;
for (char *p = str; *p != '\0'; p++) {
if (*p != delim && !(delim == '\0' && isspace(*p))) {
continue;
}
int size = p - begin;
if (size > 0) count++;
}
count++;
ret = malloc((count + 1) * sizeof(char*));
memset(ret, 0, (count + 1) * sizeof(char*));
begin = str;
int i = 0;
bool finished = false;
for (char *p = str; !finished; p++) {
if (*p == '\0') finished = true;
if (*p != delim && *p != '\0' && !(delim == '\0' && isspace(*p))) {
continue;
}
int size = p - begin;
if (size == 0) {
begin = p + 1;
continue;
}
char *buf = malloc(sizeof(char) * (size + 1));
buf[size] = '\0';
memcpy(buf, begin, size * sizeof(char));
begin = p + 1;
ret[i] = buf;
i++;
}
return ret;
}
void str_list_free(char **list) {
char **p = list;
while (*p != NULL) {
free(*p);
p++;
}
free(list);
}
char* str_strip(char *str) {
int len = strlen(str);
char *begin = str;
char *end = str + len - 1;
while (isspace(*begin) && begin < end) {
begin++;
}
while (isspace(*end) && end >= begin) {
end--;
}
len = end - begin + 1;
char *buf = malloc(sizeof(char) * (len) + 1);
buf[len] = '\0';
memcpy(buf, begin, len);
return buf;
}
void sb_init(StrBuilder *sb) {
*sb = (StrBuilder){.size = 0, .cap = 16};
sb->buf = malloc(sizeof(char) * 17);
}
static void sb_reserve(StrBuilder *sb, int extra) {
if (sb->size + extra <= sb->cap) {
return;
}
int new_cap = (sb->size + extra) * 2;
sb->buf = realloc(sb->buf, new_cap + 1);
memset(sb->buf + sb->cap, 0, new_cap - sb->cap + 1);
sb->cap = new_cap;
}
void sb_append(StrBuilder *sb, char *format, ...) {
va_list va1;
va_list va2;
va_start(va1, format);
va_copy(va2, va1);
int size = vsnprintf(NULL, 0, format, va1);
sb_reserve(sb, size);
vsnprintf(sb->buf + sb->size, sb->cap - sb->size + 1, format, va2);
}
void sb_appendc(StrBuilder *sb, char c) {
sb_reserve(sb, 1);
sb->buf[sb->size] = c;
sb->size++;
}
char* fgetline(FILE *fp) {
StrBuilder sb;
sb_init(&sb);
while (true) {
int c = fgetc(fp);
if (c == EOF && sb.size == 0) return NULL;
if (c != EOF) sb_appendc(&sb, c);
if (c == EOF || c == '\n') return sb.buf;
}
return NULL;
}
int fpeek(FILE *fp) {
int c = fgetc(fp);
if (c == EOF) return c;
ungetc(c, fp);
return c;
}
|
