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
|
/*
* Copyright 2015 WebAssembly Community Group participants
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
//
// wasm2js console tool
//
#include "support/colors.h"
#include "support/command-line.h"
#include "support/file.h"
#include "wasm-s-parser.h"
#include "wasm2js.h"
#include "tool-options.h"
using namespace cashew;
using namespace wasm;
int main(int argc, const char *argv[]) {
Wasm2JSBuilder::Flags builderFlags;
ToolOptions options("wasm2js", "Transform .wasm/.wast files to asm.js");
options
.add("--output", "-o", "Output file (stdout if not specified)",
Options::Arguments::One,
[](Options* o, const std::string& argument) {
o->extra["output"] = argument;
Colors::disable();
})
.add("--allow-asserts", "", "Allow compilation of .wast testing asserts",
Options::Arguments::Zero,
[&](Options* o, const std::string& argument) {
builderFlags.allowAsserts = true;
o->extra["asserts"] = "1";
})
.add("--pedantic", "", "Emulate WebAssembly trapping behavior",
Options::Arguments::Zero,
[&](Options* o, const std::string& argument) {
builderFlags.pedantic = true;
})
.add_positional("INFILE", Options::Arguments::One,
[](Options *o, const std::string& argument) {
o->extra["infile"] = argument;
});
options.parse(argc, argv);
if (options.debug) builderFlags.debug = true;
Element* root = nullptr;
Module wasm;
Ref asmjs;
std::unique_ptr<SExpressionParser> sexprParser;
std::unique_ptr<SExpressionWasmBuilder> sexprBuilder;
auto &input = options.extra["infile"];
std::string suffix(".wasm");
bool binaryInput =
input.size() >= suffix.size() &&
input.compare(input.size() - suffix.size(), suffix.size(), suffix) == 0;
try {
// If the input filename ends in `.wasm`, then parse it in binary form,
// otherwise assume it's a `*.wast` file and go from there.
//
// Note that we're not using the built-in `ModuleReader` which will also do
// similar logic here because when testing JS files we use the
// `--allow-asserts` flag which means we need to parse the extra
// s-expressions that come at the end of the `*.wast` file after the module
// is defined.
if (binaryInput) {
ModuleReader reader;
reader.setDebug(options.debug);
reader.read(input, wasm, "");
options.calculateFeatures(wasm);
} else {
auto input(
read_file<std::vector<char>>(options.extra["infile"], Flags::Text, options.debug ? Flags::Debug : Flags::Release));
if (options.debug) std::cerr << "s-parsing..." << std::endl;
sexprParser = make_unique<SExpressionParser>(input.data());
root = sexprParser->root;
if (options.debug) std::cerr << "w-parsing..." << std::endl;
sexprBuilder = make_unique<SExpressionWasmBuilder>(wasm, *(*root)[0]);
}
} catch (ParseException& p) {
p.dump(std::cerr);
Fatal() << "error in parsing input";
} catch (std::bad_alloc&) {
Fatal() << "error in building module, std::bad_alloc (possibly invalid request for silly amounts of memory)";
}
if (options.passOptions.validate) {
if (!WasmValidator().validate(wasm, options.passOptions.features)) {
WasmPrinter::printModule(&wasm);
Fatal() << "error in validating input";
}
}
if (options.debug) std::cerr << "asming..." << std::endl;
Wasm2JSBuilder wasm2js(builderFlags);
asmjs = wasm2js.processWasm(&wasm);
if (!binaryInput) {
if (options.extra["asserts"] == "1") {
if (options.debug) std::cerr << "asserting..." << std::endl;
flattenAppend(asmjs, wasm2js.processAsserts(&wasm, *root, *sexprBuilder));
}
}
if (options.debug) {
std::cerr << "a-printing..." << std::endl;
asmjs->stringify(std::cout, true);
std::cout << '\n';
}
if (options.debug) std::cerr << "j-printing..." << std::endl;
JSPrinter jser(true, true, asmjs);
jser.printAst();
Output output(options.extra["output"], Flags::Text, options.debug ? Flags::Debug : Flags::Release);
output << jser.buffer << std::endl;
if (options.debug) std::cerr << "done." << std::endl;
}
|
