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
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
|
/* neostr: various functions for manipulating strings.
* char* is the main type that is manipulated, and there is no expectation of
* Unicode, though I could implement support at some point.
*/
/* Given a string, replace all instances of orig with with, ensuring that only
* one allocation is made.
*/
#define owned
#define borrowed
#define str_discard_const (char*)
void dbg(const char *fmt, ...);
owned const char *
neostr_replace_all(const char *haystack, const char *orig, const char *with)
{
int count, to_malloc;
size_t len_orig, len_with;
char *buf, *index_from, *index_to, *buf_cpos, *haystack_tmp, *ss;
len_orig = strlen(orig);
len_with = strlen(with);
count = 0;
haystack_tmp = str_discard_const haystack;
for (;;)
{
ss = strstr(haystack_tmp, orig);
if (!ss)
break;
count++;
haystack_tmp += (ss - haystack_tmp) + len_orig;
}
/* Allocate the new buffer */
to_malloc = strlen(haystack)
- (count * len_orig)
+ (count * len_with);
buf = (char*)malloc(to_malloc);
memset(buf, 0, to_malloc);
/* Copy until the text to substitute is found, then copy the new text into
* buf, incrementing the counter in the haystack by len_orig.
*/
index_from = str_discard_const haystack;
buf_cpos = buf;
while ((index_to = strstr(index_from, orig)) != NULL)
{
memcpy(buf_cpos, index_from, (index_to - index_from));
buf_cpos += (index_to - index_from);
memcpy(buf_cpos, with, len_with);
buf_cpos += len_with;
index_from = index_to + len_orig;
}
/* Finally, copy any remaining non-substituted contents. */
memcpy(buf_cpos, index_from, strlen(haystack) - (index_from - haystack));
buf[to_malloc] = '\0';
return buf;
}
/* In a single allocation, replace all instances of the prefix at the start of
* the line with a circumfix, at the start and end of the line.
*/
owned char *
neostr_linewise_replace_prefix_with_circumfix(const char *haystack,
const char *prefix,
const char *circumfix_start,
const char *circumfix_end)
{
int prefix_len = strlen(prefix),
circumfix_start_len = strlen(circumfix_start),
circumfix_end_len = strlen(circumfix_end);
/* Count of affected lines */
int count = 0;
char *haystack_tmp = str_discard_const haystack, *nl;
for (;;)
{
nl = strstr(haystack_tmp, "\n");
if (!nl)
break;
count++;
haystack_tmp += (nl - haystack_tmp) + 1;
}
dbg("count :: %d\n", count);
int to_malloc = strlen(haystack)
- (count * prefix_len)
+ (count * (circumfix_start_len + circumfix_start_len));
dbg("prefix_with_circumfix: to malloc %d bytes\n", to_malloc);
char *buf = malloc(to_malloc);
if (!buf)
return NULL;
/* Copy into the buffer. */
/* 1) Copy until the first strstr of '\n'.
* 2) If the line begins with prefix:
* 2a) Copy circumfix_start.
* 2b) Copy from the (strstr + prefix_len) to the next strstr of '\n'.
* 2c) Copy circumfix_end.
* 2z) Else, just copy the whole line until strstr of '\n'.
* 3) Once strstr of '\n' returns NULL, just copy until the end of the string.
*
* Given it is always linewise, at any given time, line_begin and line_end refer to the line.
*/
char *line_begin, *line_end;
int line_len;
char *buf_idx;
buf_idx = buf;
line_begin = str_discard_const haystack;
line_end = strstr(haystack, "\n");
line_len = line_end - line_begin;
dbg("Initialized line: %.*s", line_len, line_begin);
while (true)
{
dbg("\n\nBegun loop.\n");
dbg("Sizeof haystack: %d; Sizeof line begin offset: %d\n", strlen(haystack), line_begin - haystack);
dbg("Sizeof alloc: %d; Sizeof buf: %d\n", to_malloc, buf_idx - buf);
dbg("Strncmp of [%.*s] and [%s]\n", prefix_len, line_begin, prefix);
if (strncmp(line_begin, prefix, prefix_len) == 0)
{
dbg(" Circumfix line [%.*s].\n", line_len, line_begin);
memcpy(buf_idx, circumfix_start, circumfix_start_len);
buf_idx += circumfix_start_len;
memcpy(buf_idx, line_begin + prefix_len, line_len - prefix_len);
buf_idx += (line_len - prefix_len);
memcpy(buf_idx, circumfix_end, circumfix_end_len);
buf_idx += circumfix_end_len;
}
else
{
dbg(" Normal line [%.*s].\n", line_len, line_begin);
memcpy(buf_idx, line_begin, line_len);
buf_idx += line_len;
}
dbg("Buf is [%.*s]\n", buf_idx - buf, buf);
/* Append the newline. */
*buf_idx = '\n';
buf_idx++;
/* Go to next line. */
while (true)
{
line_begin = line_end + 1;
line_end = strstr(line_begin, "\n");
if (!line_end)
goto final_line;
line_len = line_end - line_begin;
if (line_len == 0)
{
dbg("Line length zero.\n");
*buf_idx = '\n';
buf_idx++;
continue;
}
break;
}
}
final_line:
dbg("final line{{%.*s}}\n", (haystack + strlen(haystack)), line_begin);
memcpy(buf_idx, line_begin, (haystack + strlen(haystack)) - line_begin);
return buf;
}
|
