static void on_option(struct WasmOptionParser* parser,
struct WasmOption* option,
const char* argument) {
switch (option->id) {
case FLAG_VERBOSE:
s_verbose++;
wasm_init_file_writer_existing(&s_log_stream_writer, stdout);
wasm_init_stream(&s_log_stream, &s_log_stream_writer.base, NULL);
s_read_binary_options.log_stream = &s_log_stream;
break;
case FLAG_HELP:
wasm_print_help(parser, PROGRAM_NAME);
exit(0);
break;
case FLAG_OUTPUT:
s_outfile = argument;
break;
case FLAG_USE_LIBC_ALLOCATOR:
s_use_libc_allocator = WASM_TRUE;
break;
case FLAG_DEBUG_NAMES:
s_read_binary_options.read_debug_names = WASM_TRUE;
break;
case FLAG_GENERATE_NAMES:
s_generate_names = WASM_TRUE;
break;
}
}
WasmResult wasm_init_file_writer(WasmFileWriter* writer, const char* filename) {
FILE* file = fopen(filename, "wb");
if (!file) {
ERROR("fopen name=\"%s\" failed, errno=%d\n", filename, errno);
return WASM_ERROR;
}
wasm_init_file_writer_existing(writer, file);
return WASM_OK;
}
int main(int argc, char** argv) {
WasmResult result;
WasmStackAllocator stack_allocator;
WasmAllocator* allocator;
wasm_init_stdio();
parse_options(argc, argv);
if (s_use_libc_allocator) {
allocator = &g_wasm_libc_allocator;
} else {
wasm_init_stack_allocator(&stack_allocator, &g_wasm_libc_allocator);
allocator = &stack_allocator.allocator;
}
void* data;
size_t size;
result = wasm_read_file(allocator, s_infile, &data, &size);
if (WASM_SUCCEEDED(result)) {
WasmModule module;
WASM_ZERO_MEMORY(module);
result = wasm_read_binary_ast(allocator, data, size, &s_read_binary_options,
&s_error_handler, &module);
if (WASM_SUCCEEDED(result)) {
if (s_generate_names)
result = wasm_generate_names(allocator, &module);
if (WASM_SUCCEEDED(result))
result = wasm_apply_names(allocator, &module);
if (WASM_SUCCEEDED(result)) {
WasmFileWriter file_writer;
if (s_outfile) {
result = wasm_init_file_writer(&file_writer, s_outfile);
} else {
wasm_init_file_writer_existing(&file_writer, stdout);
}
if (WASM_SUCCEEDED(result)) {
result = wasm_write_ast(allocator, &file_writer.base, &module);
wasm_close_file_writer(&file_writer);
}
}
}
if (s_use_libc_allocator)
wasm_destroy_module(allocator, &module);
wasm_free(allocator, data);
wasm_print_allocator_stats(allocator);
wasm_destroy_allocator(allocator);
}
return result;
}
int main(int argc, char** argv) {
WasmStackAllocator stack_allocator;
WasmAllocator* allocator;
wasm_init_stdio();
wasm_init_file_writer_existing(&s_log_stream_writer, stdout);
wasm_init_stream(&s_log_stream, &s_log_stream_writer.base, NULL);
parse_options(argc, argv);
if (s_use_libc_allocator) {
allocator = &g_wasm_libc_allocator;
} else {
wasm_init_stack_allocator(&stack_allocator, &g_wasm_libc_allocator);
allocator = &stack_allocator.allocator;
}
WasmAstLexer* lexer = wasm_new_ast_file_lexer(allocator, s_infile);
if (!lexer)
WASM_FATAL("unable to read %s\n", s_infile);
WasmScript script;
WasmResult result = wasm_parse_ast(lexer, &script, &s_error_handler);
if (WASM_SUCCEEDED(result)) {
result =
wasm_resolve_names_script(allocator, lexer, &script, &s_error_handler);
if (WASM_SUCCEEDED(result) && s_validate) {
result =
wasm_validate_script(allocator, lexer, &script, &s_error_handler);
}
if (WASM_SUCCEEDED(result) && s_validate_assert_invalid_and_malformed) {
WasmDefaultErrorHandlerInfo assert_invalid_info;
WasmSourceErrorHandler assert_invalid_error_handler;
init_source_error_handler(&assert_invalid_error_handler,
&assert_invalid_info, "assert_invalid error");
WasmDefaultErrorHandlerInfo assert_malformed_info;
WasmSourceErrorHandler assert_malformed_error_handler;
init_source_error_handler(&assert_malformed_error_handler,
&assert_malformed_info,
"assert_malformed error");
result = wasm_validate_assert_invalid_and_malformed(
allocator, lexer, &script, &assert_invalid_error_handler,
&assert_malformed_error_handler, &s_error_handler);
}
if (WASM_SUCCEEDED(result)) {
if (s_spec) {
s_write_binary_spec_options.json_filename = s_outfile;
s_write_binary_spec_options.write_binary_options =
s_write_binary_options;
result = wasm_write_binary_spec_script(allocator, &script, s_infile,
&s_write_binary_spec_options);
} else {
WasmMemoryWriter writer;
WASM_ZERO_MEMORY(writer);
if (WASM_FAILED(wasm_init_mem_writer(allocator, &writer)))
WASM_FATAL("unable to open memory writer for writing\n");
result = wasm_write_binary_script(allocator, &writer.base, &script,
&s_write_binary_options);
if (WASM_SUCCEEDED(result))
write_buffer_to_file(s_outfile, &writer.buf);
wasm_close_mem_writer(&writer);
}
}
}
wasm_destroy_ast_lexer(lexer);
if (s_use_libc_allocator)
wasm_destroy_script(&script);
wasm_print_allocator_stats(allocator);
wasm_destroy_allocator(allocator);
return result;
}
void wasm_init_file_stream_from_existing(WasmFileStream* stream, FILE* file) {
wasm_init_file_writer_existing(&stream->writer, file);
wasm_init_stream(&stream->base, &stream->writer.base, NULL);
}