static void ensure_output_buffer_capacity(WasmOutputBuffer* buf,
size_t ensure_capacity) {
if (ensure_capacity > buf->capacity) {
assert(buf->capacity != 0);
size_t new_capacity = buf->capacity * 2;
while (new_capacity < ensure_capacity)
new_capacity *= 2;
buf->start = wasm_realloc(buf->allocator, buf->start, new_capacity,
WASM_DEFAULT_ALIGN);
buf->capacity = new_capacity;
}
}
void wasm_ensure_capacity(WasmAllocator* allocator,
void** data,
size_t* capacity,
size_t desired_size,
size_t elt_byte_size) {
if (desired_size > *capacity) {
size_t new_capacity = *capacity ? *capacity * 2 : INITIAL_VECTOR_CAPACITY;
while (new_capacity < desired_size)
new_capacity *= 2;
size_t new_byte_size = new_capacity * elt_byte_size;
*data = wasm_realloc(allocator, *data, new_byte_size, WASM_DEFAULT_ALIGN);
*capacity = new_capacity;
}
}
static WasmResult fill(WasmLocation* loc,
WasmAstLexer* lexer,
WasmAstParser* parser,
size_t need) {
if (lexer->eof)
return WASM_ERROR;
size_t free = lexer->token - lexer->buffer;
assert((size_t)(lexer->cursor - lexer->buffer) >= free);
/* our buffer is too small, need to realloc */
if (free < need) {
char* old_buffer = lexer->buffer;
size_t old_buffer_size = lexer->buffer_size;
size_t new_buffer_size =
old_buffer_size ? old_buffer_size * 2 : INITIAL_LEXER_BUFFER_SIZE;
/* make sure there is enough space for the bytes requested (need) and an
* additional YYMAXFILL bytes which is needed for the re2c lexer
* implementation when the eof is reached */
while ((new_buffer_size - old_buffer_size) + free < need + YYMAXFILL)
new_buffer_size *= 2;
/* TODO(binji): could just alloc instead, because we know we'll need to
* memmove below */
char* new_buffer = wasm_realloc(lexer->allocator, lexer->buffer,
new_buffer_size, WASM_DEFAULT_ALIGN);
if (new_buffer == NULL) {
wasm_ast_parser_error(loc, lexer, parser,
"unable to reallocate lexer buffer.");
return WASM_ERROR;
}
memmove(new_buffer, lexer->token, lexer->limit - lexer->token);
lexer->buffer = new_buffer;
lexer->buffer_size = new_buffer_size;
lexer->token = new_buffer + (lexer->token - old_buffer) - free;
lexer->marker = new_buffer + (lexer->marker - old_buffer) - free;
lexer->cursor = new_buffer + (lexer->cursor - old_buffer) - free;
lexer->limit = new_buffer + (lexer->limit - old_buffer) - free;
lexer->buffer_file_offset += free;
free += new_buffer_size - old_buffer_size;
} else {
/* shift everything down to make more room in the buffer */
memmove(lexer->buffer, lexer->token, lexer->limit - lexer->token);
lexer->token -= free;
lexer->marker -= free;
lexer->cursor -= free;
lexer->limit -= free;
lexer->buffer_file_offset += free;
}
/* read the new data into the buffer */
if (lexer->source.type == WASM_LEXER_SOURCE_TYPE_FILE) {
lexer->limit += fread(lexer->limit, 1, free, lexer->source.file);
} else {
/* TODO(binji): could lex directly from buffer */
assert(lexer->source.type == WASM_LEXER_SOURCE_TYPE_BUFFER);
size_t read_size = free;
size_t offset = lexer->source.buffer.read_offset;
size_t bytes_left = lexer->source.buffer.size - offset;
if (read_size > bytes_left)
read_size = bytes_left;
memcpy(lexer->buffer, (char*)lexer->source.buffer.data + offset,
read_size);
lexer->source.buffer.read_offset += read_size;
lexer->limit += read_size;
}
/* if at the end of file, need to fill YYMAXFILL more characters with "fake
* characters", that are not a lexeme nor a lexeme suffix. see
* http://re2c.org/examples/example_03.html */
if (lexer->limit < lexer->buffer + lexer->buffer_size - YYMAXFILL) {
lexer->eof = WASM_TRUE;
memset(lexer->limit, 0, YYMAXFILL);
lexer->limit += YYMAXFILL;
}
return WASM_OK;
}
