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
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
|
#include "yarp/util/yp_string.h"
// The following headers are necessary to read files using demand paging.
#ifdef _WIN32
#include <windows.h>
#else
#include <fcntl.h>
#include <sys/mman.h>
#include <sys/stat.h>
#include <unistd.h>
#endif
// Initialize a shared string that is based on initial input.
void
yp_string_shared_init(yp_string_t *string, const uint8_t *start, const uint8_t *end) {
assert(start <= end);
*string = (yp_string_t) {
.type = YP_STRING_SHARED,
.source = start,
.length = (size_t) (end - start)
};
}
// Initialize an owned string that is responsible for freeing allocated memory.
void
yp_string_owned_init(yp_string_t *string, uint8_t *source, size_t length) {
*string = (yp_string_t) {
.type = YP_STRING_OWNED,
.source = source,
.length = length
};
}
// Initialize a constant string that doesn't own its memory source.
void
yp_string_constant_init(yp_string_t *string, const char *source, size_t length) {
*string = (yp_string_t) {
.type = YP_STRING_CONSTANT,
.source = (const uint8_t *) source,
.length = length
};
}
static void
yp_string_mapped_init_internal(yp_string_t *string, uint8_t *source, size_t length) {
*string = (yp_string_t) {
.type = YP_STRING_MAPPED,
.source = source,
.length = length
};
}
// Returns the memory size associated with the string.
size_t
yp_string_memsize(const yp_string_t *string) {
size_t size = sizeof(yp_string_t);
if (string->type == YP_STRING_OWNED) {
size += string->length;
}
return size;
}
// Ensure the string is owned. If it is not, then reinitialize it as owned and
// copy over the previous source.
void
yp_string_ensure_owned(yp_string_t *string) {
if (string->type == YP_STRING_OWNED) return;
size_t length = yp_string_length(string);
const uint8_t *source = yp_string_source(string);
uint8_t *memory = malloc(length);
if (!memory) return;
yp_string_owned_init(string, memory, length);
memcpy((void *) string->source, source, length);
}
// Returns the length associated with the string.
YP_EXPORTED_FUNCTION size_t
yp_string_length(const yp_string_t *string) {
return string->length;
}
// Returns the start pointer associated with the string.
YP_EXPORTED_FUNCTION const uint8_t *
yp_string_source(const yp_string_t *string) {
return string->source;
}
// Free the associated memory of the given string.
YP_EXPORTED_FUNCTION void
yp_string_free(yp_string_t *string) {
void *memory = (void *) string->source;
if (string->type == YP_STRING_OWNED) {
free(memory);
} else if (string->type == YP_STRING_MAPPED && string->length) {
#if defined(_WIN32)
UnmapViewOfFile(memory);
#else
munmap(memory, string->length);
#endif
}
}
bool
yp_string_mapped_init(yp_string_t *string, const char *filepath) {
#ifdef _WIN32
// Open the file for reading.
HANDLE file = CreateFile(filepath, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
if (file == INVALID_HANDLE_VALUE) {
perror("CreateFile failed");
return false;
}
// Get the file size.
DWORD file_size = GetFileSize(file, NULL);
if (file_size == INVALID_FILE_SIZE) {
CloseHandle(file);
perror("GetFileSize failed");
return false;
}
// If the file is empty, then we don't need to do anything else, we'll set
// the source to a constant empty string and return.
if (file_size == 0) {
CloseHandle(file);
uint8_t empty[] = "";
yp_string_mapped_init_internal(string, empty, 0);
return true;
}
// Create a mapping of the file.
HANDLE mapping = CreateFileMapping(file, NULL, PAGE_READONLY, 0, 0, NULL);
if (mapping == NULL) {
CloseHandle(file);
perror("CreateFileMapping failed");
return false;
}
// Map the file into memory.
uint8_t *source = (uint8_t *) MapViewOfFile(mapping, FILE_MAP_READ, 0, 0, 0);
CloseHandle(mapping);
CloseHandle(file);
if (source == NULL) {
perror("MapViewOfFile failed");
return false;
}
yp_string_mapped_init_internal(string, source, (size_t) file_size);
return true;
#else
// Open the file for reading
int fd = open(filepath, O_RDONLY);
if (fd == -1) {
perror("open");
return false;
}
// Stat the file to get the file size
struct stat sb;
if (fstat(fd, &sb) == -1) {
close(fd);
perror("fstat");
return false;
}
// mmap the file descriptor to virtually get the contents
size_t size = (size_t) sb.st_size;
uint8_t *source = NULL;
if (size == 0) {
close(fd);
uint8_t empty[] = "";
yp_string_mapped_init_internal(string, empty, 0);
return true;
}
source = mmap(NULL, size, PROT_READ, MAP_PRIVATE, fd, 0);
if (source == MAP_FAILED) {
perror("Map failed");
return false;
}
close(fd);
yp_string_mapped_init_internal(string, source, size);
return true;
#endif
}
// Returns the size of the yp_string_t struct. This is necessary to allocate the
// correct amount of memory in the FFI backend.
YP_EXPORTED_FUNCTION size_t
yp_string_sizeof(void) {
return sizeof(yp_string_t);
}
|
