| [79a0317] | 1 | "use strict";
|
|---|
| 2 | Object.defineProperty(exports, "__esModule", { value: true });
|
|---|
| 3 | exports.or = exports.and = exports.not = exports.CodeGen = exports.operators = exports.varKinds = exports.ValueScopeName = exports.ValueScope = exports.Scope = exports.Name = exports.regexpCode = exports.stringify = exports.getProperty = exports.nil = exports.strConcat = exports.str = exports._ = void 0;
|
|---|
| 4 | const code_1 = require("./code");
|
|---|
| 5 | const scope_1 = require("./scope");
|
|---|
| 6 | var code_2 = require("./code");
|
|---|
| 7 | Object.defineProperty(exports, "_", { enumerable: true, get: function () { return code_2._; } });
|
|---|
| 8 | Object.defineProperty(exports, "str", { enumerable: true, get: function () { return code_2.str; } });
|
|---|
| 9 | Object.defineProperty(exports, "strConcat", { enumerable: true, get: function () { return code_2.strConcat; } });
|
|---|
| 10 | Object.defineProperty(exports, "nil", { enumerable: true, get: function () { return code_2.nil; } });
|
|---|
| 11 | Object.defineProperty(exports, "getProperty", { enumerable: true, get: function () { return code_2.getProperty; } });
|
|---|
| 12 | Object.defineProperty(exports, "stringify", { enumerable: true, get: function () { return code_2.stringify; } });
|
|---|
| 13 | Object.defineProperty(exports, "regexpCode", { enumerable: true, get: function () { return code_2.regexpCode; } });
|
|---|
| 14 | Object.defineProperty(exports, "Name", { enumerable: true, get: function () { return code_2.Name; } });
|
|---|
| 15 | var scope_2 = require("./scope");
|
|---|
| 16 | Object.defineProperty(exports, "Scope", { enumerable: true, get: function () { return scope_2.Scope; } });
|
|---|
| 17 | Object.defineProperty(exports, "ValueScope", { enumerable: true, get: function () { return scope_2.ValueScope; } });
|
|---|
| 18 | Object.defineProperty(exports, "ValueScopeName", { enumerable: true, get: function () { return scope_2.ValueScopeName; } });
|
|---|
| 19 | Object.defineProperty(exports, "varKinds", { enumerable: true, get: function () { return scope_2.varKinds; } });
|
|---|
| 20 | exports.operators = {
|
|---|
| 21 | GT: new code_1._Code(">"),
|
|---|
| 22 | GTE: new code_1._Code(">="),
|
|---|
| 23 | LT: new code_1._Code("<"),
|
|---|
| 24 | LTE: new code_1._Code("<="),
|
|---|
| 25 | EQ: new code_1._Code("==="),
|
|---|
| 26 | NEQ: new code_1._Code("!=="),
|
|---|
| 27 | NOT: new code_1._Code("!"),
|
|---|
| 28 | OR: new code_1._Code("||"),
|
|---|
| 29 | AND: new code_1._Code("&&"),
|
|---|
| 30 | ADD: new code_1._Code("+"),
|
|---|
| 31 | };
|
|---|
| 32 | class Node {
|
|---|
| 33 | optimizeNodes() {
|
|---|
| 34 | return this;
|
|---|
| 35 | }
|
|---|
| 36 | optimizeNames(_names, _constants) {
|
|---|
| 37 | return this;
|
|---|
| 38 | }
|
|---|
| 39 | }
|
|---|
| 40 | class Def extends Node {
|
|---|
| 41 | constructor(varKind, name, rhs) {
|
|---|
| 42 | super();
|
|---|
| 43 | this.varKind = varKind;
|
|---|
| 44 | this.name = name;
|
|---|
| 45 | this.rhs = rhs;
|
|---|
| 46 | }
|
|---|
| 47 | render({ es5, _n }) {
|
|---|
| 48 | const varKind = es5 ? scope_1.varKinds.var : this.varKind;
|
|---|
| 49 | const rhs = this.rhs === undefined ? "" : ` = ${this.rhs}`;
|
|---|
| 50 | return `${varKind} ${this.name}${rhs};` + _n;
|
|---|
| 51 | }
|
|---|
| 52 | optimizeNames(names, constants) {
|
|---|
| 53 | if (!names[this.name.str])
|
|---|
| 54 | return;
|
|---|
| 55 | if (this.rhs)
|
|---|
| 56 | this.rhs = optimizeExpr(this.rhs, names, constants);
|
|---|
| 57 | return this;
|
|---|
| 58 | }
|
|---|
| 59 | get names() {
|
|---|
| 60 | return this.rhs instanceof code_1._CodeOrName ? this.rhs.names : {};
|
|---|
| 61 | }
|
|---|
| 62 | }
|
|---|
| 63 | class Assign extends Node {
|
|---|
| 64 | constructor(lhs, rhs, sideEffects) {
|
|---|
| 65 | super();
|
|---|
| 66 | this.lhs = lhs;
|
|---|
| 67 | this.rhs = rhs;
|
|---|
| 68 | this.sideEffects = sideEffects;
|
|---|
| 69 | }
|
|---|
| 70 | render({ _n }) {
|
|---|
| 71 | return `${this.lhs} = ${this.rhs};` + _n;
|
|---|
| 72 | }
|
|---|
| 73 | optimizeNames(names, constants) {
|
|---|
| 74 | if (this.lhs instanceof code_1.Name && !names[this.lhs.str] && !this.sideEffects)
|
|---|
| 75 | return;
|
|---|
| 76 | this.rhs = optimizeExpr(this.rhs, names, constants);
|
|---|
| 77 | return this;
|
|---|
| 78 | }
|
|---|
| 79 | get names() {
|
|---|
| 80 | const names = this.lhs instanceof code_1.Name ? {} : { ...this.lhs.names };
|
|---|
| 81 | return addExprNames(names, this.rhs);
|
|---|
| 82 | }
|
|---|
| 83 | }
|
|---|
| 84 | class AssignOp extends Assign {
|
|---|
| 85 | constructor(lhs, op, rhs, sideEffects) {
|
|---|
| 86 | super(lhs, rhs, sideEffects);
|
|---|
| 87 | this.op = op;
|
|---|
| 88 | }
|
|---|
| 89 | render({ _n }) {
|
|---|
| 90 | return `${this.lhs} ${this.op}= ${this.rhs};` + _n;
|
|---|
| 91 | }
|
|---|
| 92 | }
|
|---|
| 93 | class Label extends Node {
|
|---|
| 94 | constructor(label) {
|
|---|
| 95 | super();
|
|---|
| 96 | this.label = label;
|
|---|
| 97 | this.names = {};
|
|---|
| 98 | }
|
|---|
| 99 | render({ _n }) {
|
|---|
| 100 | return `${this.label}:` + _n;
|
|---|
| 101 | }
|
|---|
| 102 | }
|
|---|
| 103 | class Break extends Node {
|
|---|
| 104 | constructor(label) {
|
|---|
| 105 | super();
|
|---|
| 106 | this.label = label;
|
|---|
| 107 | this.names = {};
|
|---|
| 108 | }
|
|---|
| 109 | render({ _n }) {
|
|---|
| 110 | const label = this.label ? ` ${this.label}` : "";
|
|---|
| 111 | return `break${label};` + _n;
|
|---|
| 112 | }
|
|---|
| 113 | }
|
|---|
| 114 | class Throw extends Node {
|
|---|
| 115 | constructor(error) {
|
|---|
| 116 | super();
|
|---|
| 117 | this.error = error;
|
|---|
| 118 | }
|
|---|
| 119 | render({ _n }) {
|
|---|
| 120 | return `throw ${this.error};` + _n;
|
|---|
| 121 | }
|
|---|
| 122 | get names() {
|
|---|
| 123 | return this.error.names;
|
|---|
| 124 | }
|
|---|
| 125 | }
|
|---|
| 126 | class AnyCode extends Node {
|
|---|
| 127 | constructor(code) {
|
|---|
| 128 | super();
|
|---|
| 129 | this.code = code;
|
|---|
| 130 | }
|
|---|
| 131 | render({ _n }) {
|
|---|
| 132 | return `${this.code};` + _n;
|
|---|
| 133 | }
|
|---|
| 134 | optimizeNodes() {
|
|---|
| 135 | return `${this.code}` ? this : undefined;
|
|---|
| 136 | }
|
|---|
| 137 | optimizeNames(names, constants) {
|
|---|
| 138 | this.code = optimizeExpr(this.code, names, constants);
|
|---|
| 139 | return this;
|
|---|
| 140 | }
|
|---|
| 141 | get names() {
|
|---|
| 142 | return this.code instanceof code_1._CodeOrName ? this.code.names : {};
|
|---|
| 143 | }
|
|---|
| 144 | }
|
|---|
| 145 | class ParentNode extends Node {
|
|---|
| 146 | constructor(nodes = []) {
|
|---|
| 147 | super();
|
|---|
| 148 | this.nodes = nodes;
|
|---|
| 149 | }
|
|---|
| 150 | render(opts) {
|
|---|
| 151 | return this.nodes.reduce((code, n) => code + n.render(opts), "");
|
|---|
| 152 | }
|
|---|
| 153 | optimizeNodes() {
|
|---|
| 154 | const { nodes } = this;
|
|---|
| 155 | let i = nodes.length;
|
|---|
| 156 | while (i--) {
|
|---|
| 157 | const n = nodes[i].optimizeNodes();
|
|---|
| 158 | if (Array.isArray(n))
|
|---|
| 159 | nodes.splice(i, 1, ...n);
|
|---|
| 160 | else if (n)
|
|---|
| 161 | nodes[i] = n;
|
|---|
| 162 | else
|
|---|
| 163 | nodes.splice(i, 1);
|
|---|
| 164 | }
|
|---|
| 165 | return nodes.length > 0 ? this : undefined;
|
|---|
| 166 | }
|
|---|
| 167 | optimizeNames(names, constants) {
|
|---|
| 168 | const { nodes } = this;
|
|---|
| 169 | let i = nodes.length;
|
|---|
| 170 | while (i--) {
|
|---|
| 171 | // iterating backwards improves 1-pass optimization
|
|---|
| 172 | const n = nodes[i];
|
|---|
| 173 | if (n.optimizeNames(names, constants))
|
|---|
| 174 | continue;
|
|---|
| 175 | subtractNames(names, n.names);
|
|---|
| 176 | nodes.splice(i, 1);
|
|---|
| 177 | }
|
|---|
| 178 | return nodes.length > 0 ? this : undefined;
|
|---|
| 179 | }
|
|---|
| 180 | get names() {
|
|---|
| 181 | return this.nodes.reduce((names, n) => addNames(names, n.names), {});
|
|---|
| 182 | }
|
|---|
| 183 | }
|
|---|
| 184 | class BlockNode extends ParentNode {
|
|---|
| 185 | render(opts) {
|
|---|
| 186 | return "{" + opts._n + super.render(opts) + "}" + opts._n;
|
|---|
| 187 | }
|
|---|
| 188 | }
|
|---|
| 189 | class Root extends ParentNode {
|
|---|
| 190 | }
|
|---|
| 191 | class Else extends BlockNode {
|
|---|
| 192 | }
|
|---|
| 193 | Else.kind = "else";
|
|---|
| 194 | class If extends BlockNode {
|
|---|
| 195 | constructor(condition, nodes) {
|
|---|
| 196 | super(nodes);
|
|---|
| 197 | this.condition = condition;
|
|---|
| 198 | }
|
|---|
| 199 | render(opts) {
|
|---|
| 200 | let code = `if(${this.condition})` + super.render(opts);
|
|---|
| 201 | if (this.else)
|
|---|
| 202 | code += "else " + this.else.render(opts);
|
|---|
| 203 | return code;
|
|---|
| 204 | }
|
|---|
| 205 | optimizeNodes() {
|
|---|
| 206 | super.optimizeNodes();
|
|---|
| 207 | const cond = this.condition;
|
|---|
| 208 | if (cond === true)
|
|---|
| 209 | return this.nodes; // else is ignored here
|
|---|
| 210 | let e = this.else;
|
|---|
| 211 | if (e) {
|
|---|
| 212 | const ns = e.optimizeNodes();
|
|---|
| 213 | e = this.else = Array.isArray(ns) ? new Else(ns) : ns;
|
|---|
| 214 | }
|
|---|
| 215 | if (e) {
|
|---|
| 216 | if (cond === false)
|
|---|
| 217 | return e instanceof If ? e : e.nodes;
|
|---|
| 218 | if (this.nodes.length)
|
|---|
| 219 | return this;
|
|---|
| 220 | return new If(not(cond), e instanceof If ? [e] : e.nodes);
|
|---|
| 221 | }
|
|---|
| 222 | if (cond === false || !this.nodes.length)
|
|---|
| 223 | return undefined;
|
|---|
| 224 | return this;
|
|---|
| 225 | }
|
|---|
| 226 | optimizeNames(names, constants) {
|
|---|
| 227 | var _a;
|
|---|
| 228 | this.else = (_a = this.else) === null || _a === void 0 ? void 0 : _a.optimizeNames(names, constants);
|
|---|
| 229 | if (!(super.optimizeNames(names, constants) || this.else))
|
|---|
| 230 | return;
|
|---|
| 231 | this.condition = optimizeExpr(this.condition, names, constants);
|
|---|
| 232 | return this;
|
|---|
| 233 | }
|
|---|
| 234 | get names() {
|
|---|
| 235 | const names = super.names;
|
|---|
| 236 | addExprNames(names, this.condition);
|
|---|
| 237 | if (this.else)
|
|---|
| 238 | addNames(names, this.else.names);
|
|---|
| 239 | return names;
|
|---|
| 240 | }
|
|---|
| 241 | }
|
|---|
| 242 | If.kind = "if";
|
|---|
| 243 | class For extends BlockNode {
|
|---|
| 244 | }
|
|---|
| 245 | For.kind = "for";
|
|---|
| 246 | class ForLoop extends For {
|
|---|
| 247 | constructor(iteration) {
|
|---|
| 248 | super();
|
|---|
| 249 | this.iteration = iteration;
|
|---|
| 250 | }
|
|---|
| 251 | render(opts) {
|
|---|
| 252 | return `for(${this.iteration})` + super.render(opts);
|
|---|
| 253 | }
|
|---|
| 254 | optimizeNames(names, constants) {
|
|---|
| 255 | if (!super.optimizeNames(names, constants))
|
|---|
| 256 | return;
|
|---|
| 257 | this.iteration = optimizeExpr(this.iteration, names, constants);
|
|---|
| 258 | return this;
|
|---|
| 259 | }
|
|---|
| 260 | get names() {
|
|---|
| 261 | return addNames(super.names, this.iteration.names);
|
|---|
| 262 | }
|
|---|
| 263 | }
|
|---|
| 264 | class ForRange extends For {
|
|---|
| 265 | constructor(varKind, name, from, to) {
|
|---|
| 266 | super();
|
|---|
| 267 | this.varKind = varKind;
|
|---|
| 268 | this.name = name;
|
|---|
| 269 | this.from = from;
|
|---|
| 270 | this.to = to;
|
|---|
| 271 | }
|
|---|
| 272 | render(opts) {
|
|---|
| 273 | const varKind = opts.es5 ? scope_1.varKinds.var : this.varKind;
|
|---|
| 274 | const { name, from, to } = this;
|
|---|
| 275 | return `for(${varKind} ${name}=${from}; ${name}<${to}; ${name}++)` + super.render(opts);
|
|---|
| 276 | }
|
|---|
| 277 | get names() {
|
|---|
| 278 | const names = addExprNames(super.names, this.from);
|
|---|
| 279 | return addExprNames(names, this.to);
|
|---|
| 280 | }
|
|---|
| 281 | }
|
|---|
| 282 | class ForIter extends For {
|
|---|
| 283 | constructor(loop, varKind, name, iterable) {
|
|---|
| 284 | super();
|
|---|
| 285 | this.loop = loop;
|
|---|
| 286 | this.varKind = varKind;
|
|---|
| 287 | this.name = name;
|
|---|
| 288 | this.iterable = iterable;
|
|---|
| 289 | }
|
|---|
| 290 | render(opts) {
|
|---|
| 291 | return `for(${this.varKind} ${this.name} ${this.loop} ${this.iterable})` + super.render(opts);
|
|---|
| 292 | }
|
|---|
| 293 | optimizeNames(names, constants) {
|
|---|
| 294 | if (!super.optimizeNames(names, constants))
|
|---|
| 295 | return;
|
|---|
| 296 | this.iterable = optimizeExpr(this.iterable, names, constants);
|
|---|
| 297 | return this;
|
|---|
| 298 | }
|
|---|
| 299 | get names() {
|
|---|
| 300 | return addNames(super.names, this.iterable.names);
|
|---|
| 301 | }
|
|---|
| 302 | }
|
|---|
| 303 | class Func extends BlockNode {
|
|---|
| 304 | constructor(name, args, async) {
|
|---|
| 305 | super();
|
|---|
| 306 | this.name = name;
|
|---|
| 307 | this.args = args;
|
|---|
| 308 | this.async = async;
|
|---|
| 309 | }
|
|---|
| 310 | render(opts) {
|
|---|
| 311 | const _async = this.async ? "async " : "";
|
|---|
| 312 | return `${_async}function ${this.name}(${this.args})` + super.render(opts);
|
|---|
| 313 | }
|
|---|
| 314 | }
|
|---|
| 315 | Func.kind = "func";
|
|---|
| 316 | class Return extends ParentNode {
|
|---|
| 317 | render(opts) {
|
|---|
| 318 | return "return " + super.render(opts);
|
|---|
| 319 | }
|
|---|
| 320 | }
|
|---|
| 321 | Return.kind = "return";
|
|---|
| 322 | class Try extends BlockNode {
|
|---|
| 323 | render(opts) {
|
|---|
| 324 | let code = "try" + super.render(opts);
|
|---|
| 325 | if (this.catch)
|
|---|
| 326 | code += this.catch.render(opts);
|
|---|
| 327 | if (this.finally)
|
|---|
| 328 | code += this.finally.render(opts);
|
|---|
| 329 | return code;
|
|---|
| 330 | }
|
|---|
| 331 | optimizeNodes() {
|
|---|
| 332 | var _a, _b;
|
|---|
| 333 | super.optimizeNodes();
|
|---|
| 334 | (_a = this.catch) === null || _a === void 0 ? void 0 : _a.optimizeNodes();
|
|---|
| 335 | (_b = this.finally) === null || _b === void 0 ? void 0 : _b.optimizeNodes();
|
|---|
| 336 | return this;
|
|---|
| 337 | }
|
|---|
| 338 | optimizeNames(names, constants) {
|
|---|
| 339 | var _a, _b;
|
|---|
| 340 | super.optimizeNames(names, constants);
|
|---|
| 341 | (_a = this.catch) === null || _a === void 0 ? void 0 : _a.optimizeNames(names, constants);
|
|---|
| 342 | (_b = this.finally) === null || _b === void 0 ? void 0 : _b.optimizeNames(names, constants);
|
|---|
| 343 | return this;
|
|---|
| 344 | }
|
|---|
| 345 | get names() {
|
|---|
| 346 | const names = super.names;
|
|---|
| 347 | if (this.catch)
|
|---|
| 348 | addNames(names, this.catch.names);
|
|---|
| 349 | if (this.finally)
|
|---|
| 350 | addNames(names, this.finally.names);
|
|---|
| 351 | return names;
|
|---|
| 352 | }
|
|---|
| 353 | }
|
|---|
| 354 | class Catch extends BlockNode {
|
|---|
| 355 | constructor(error) {
|
|---|
| 356 | super();
|
|---|
| 357 | this.error = error;
|
|---|
| 358 | }
|
|---|
| 359 | render(opts) {
|
|---|
| 360 | return `catch(${this.error})` + super.render(opts);
|
|---|
| 361 | }
|
|---|
| 362 | }
|
|---|
| 363 | Catch.kind = "catch";
|
|---|
| 364 | class Finally extends BlockNode {
|
|---|
| 365 | render(opts) {
|
|---|
| 366 | return "finally" + super.render(opts);
|
|---|
| 367 | }
|
|---|
| 368 | }
|
|---|
| 369 | Finally.kind = "finally";
|
|---|
| 370 | class CodeGen {
|
|---|
| 371 | constructor(extScope, opts = {}) {
|
|---|
| 372 | this._values = {};
|
|---|
| 373 | this._blockStarts = [];
|
|---|
| 374 | this._constants = {};
|
|---|
| 375 | this.opts = { ...opts, _n: opts.lines ? "\n" : "" };
|
|---|
| 376 | this._extScope = extScope;
|
|---|
| 377 | this._scope = new scope_1.Scope({ parent: extScope });
|
|---|
| 378 | this._nodes = [new Root()];
|
|---|
| 379 | }
|
|---|
| 380 | toString() {
|
|---|
| 381 | return this._root.render(this.opts);
|
|---|
| 382 | }
|
|---|
| 383 | // returns unique name in the internal scope
|
|---|
| 384 | name(prefix) {
|
|---|
| 385 | return this._scope.name(prefix);
|
|---|
| 386 | }
|
|---|
| 387 | // reserves unique name in the external scope
|
|---|
| 388 | scopeName(prefix) {
|
|---|
| 389 | return this._extScope.name(prefix);
|
|---|
| 390 | }
|
|---|
| 391 | // reserves unique name in the external scope and assigns value to it
|
|---|
| 392 | scopeValue(prefixOrName, value) {
|
|---|
| 393 | const name = this._extScope.value(prefixOrName, value);
|
|---|
| 394 | const vs = this._values[name.prefix] || (this._values[name.prefix] = new Set());
|
|---|
| 395 | vs.add(name);
|
|---|
| 396 | return name;
|
|---|
| 397 | }
|
|---|
| 398 | getScopeValue(prefix, keyOrRef) {
|
|---|
| 399 | return this._extScope.getValue(prefix, keyOrRef);
|
|---|
| 400 | }
|
|---|
| 401 | // return code that assigns values in the external scope to the names that are used internally
|
|---|
| 402 | // (same names that were returned by gen.scopeName or gen.scopeValue)
|
|---|
| 403 | scopeRefs(scopeName) {
|
|---|
| 404 | return this._extScope.scopeRefs(scopeName, this._values);
|
|---|
| 405 | }
|
|---|
| 406 | scopeCode() {
|
|---|
| 407 | return this._extScope.scopeCode(this._values);
|
|---|
| 408 | }
|
|---|
| 409 | _def(varKind, nameOrPrefix, rhs, constant) {
|
|---|
| 410 | const name = this._scope.toName(nameOrPrefix);
|
|---|
| 411 | if (rhs !== undefined && constant)
|
|---|
| 412 | this._constants[name.str] = rhs;
|
|---|
| 413 | this._leafNode(new Def(varKind, name, rhs));
|
|---|
| 414 | return name;
|
|---|
| 415 | }
|
|---|
| 416 | // `const` declaration (`var` in es5 mode)
|
|---|
| 417 | const(nameOrPrefix, rhs, _constant) {
|
|---|
| 418 | return this._def(scope_1.varKinds.const, nameOrPrefix, rhs, _constant);
|
|---|
| 419 | }
|
|---|
| 420 | // `let` declaration with optional assignment (`var` in es5 mode)
|
|---|
| 421 | let(nameOrPrefix, rhs, _constant) {
|
|---|
| 422 | return this._def(scope_1.varKinds.let, nameOrPrefix, rhs, _constant);
|
|---|
| 423 | }
|
|---|
| 424 | // `var` declaration with optional assignment
|
|---|
| 425 | var(nameOrPrefix, rhs, _constant) {
|
|---|
| 426 | return this._def(scope_1.varKinds.var, nameOrPrefix, rhs, _constant);
|
|---|
| 427 | }
|
|---|
| 428 | // assignment code
|
|---|
| 429 | assign(lhs, rhs, sideEffects) {
|
|---|
| 430 | return this._leafNode(new Assign(lhs, rhs, sideEffects));
|
|---|
| 431 | }
|
|---|
| 432 | // `+=` code
|
|---|
| 433 | add(lhs, rhs) {
|
|---|
| 434 | return this._leafNode(new AssignOp(lhs, exports.operators.ADD, rhs));
|
|---|
| 435 | }
|
|---|
| 436 | // appends passed SafeExpr to code or executes Block
|
|---|
| 437 | code(c) {
|
|---|
| 438 | if (typeof c == "function")
|
|---|
| 439 | c();
|
|---|
| 440 | else if (c !== code_1.nil)
|
|---|
| 441 | this._leafNode(new AnyCode(c));
|
|---|
| 442 | return this;
|
|---|
| 443 | }
|
|---|
| 444 | // returns code for object literal for the passed argument list of key-value pairs
|
|---|
| 445 | object(...keyValues) {
|
|---|
| 446 | const code = ["{"];
|
|---|
| 447 | for (const [key, value] of keyValues) {
|
|---|
| 448 | if (code.length > 1)
|
|---|
| 449 | code.push(",");
|
|---|
| 450 | code.push(key);
|
|---|
| 451 | if (key !== value || this.opts.es5) {
|
|---|
| 452 | code.push(":");
|
|---|
| 453 | (0, code_1.addCodeArg)(code, value);
|
|---|
| 454 | }
|
|---|
| 455 | }
|
|---|
| 456 | code.push("}");
|
|---|
| 457 | return new code_1._Code(code);
|
|---|
| 458 | }
|
|---|
| 459 | // `if` clause (or statement if `thenBody` and, optionally, `elseBody` are passed)
|
|---|
| 460 | if(condition, thenBody, elseBody) {
|
|---|
| 461 | this._blockNode(new If(condition));
|
|---|
| 462 | if (thenBody && elseBody) {
|
|---|
| 463 | this.code(thenBody).else().code(elseBody).endIf();
|
|---|
| 464 | }
|
|---|
| 465 | else if (thenBody) {
|
|---|
| 466 | this.code(thenBody).endIf();
|
|---|
| 467 | }
|
|---|
| 468 | else if (elseBody) {
|
|---|
| 469 | throw new Error('CodeGen: "else" body without "then" body');
|
|---|
| 470 | }
|
|---|
| 471 | return this;
|
|---|
| 472 | }
|
|---|
| 473 | // `else if` clause - invalid without `if` or after `else` clauses
|
|---|
| 474 | elseIf(condition) {
|
|---|
| 475 | return this._elseNode(new If(condition));
|
|---|
| 476 | }
|
|---|
| 477 | // `else` clause - only valid after `if` or `else if` clauses
|
|---|
| 478 | else() {
|
|---|
| 479 | return this._elseNode(new Else());
|
|---|
| 480 | }
|
|---|
| 481 | // end `if` statement (needed if gen.if was used only with condition)
|
|---|
| 482 | endIf() {
|
|---|
| 483 | return this._endBlockNode(If, Else);
|
|---|
| 484 | }
|
|---|
| 485 | _for(node, forBody) {
|
|---|
| 486 | this._blockNode(node);
|
|---|
| 487 | if (forBody)
|
|---|
| 488 | this.code(forBody).endFor();
|
|---|
| 489 | return this;
|
|---|
| 490 | }
|
|---|
| 491 | // a generic `for` clause (or statement if `forBody` is passed)
|
|---|
| 492 | for(iteration, forBody) {
|
|---|
| 493 | return this._for(new ForLoop(iteration), forBody);
|
|---|
| 494 | }
|
|---|
| 495 | // `for` statement for a range of values
|
|---|
| 496 | forRange(nameOrPrefix, from, to, forBody, varKind = this.opts.es5 ? scope_1.varKinds.var : scope_1.varKinds.let) {
|
|---|
| 497 | const name = this._scope.toName(nameOrPrefix);
|
|---|
| 498 | return this._for(new ForRange(varKind, name, from, to), () => forBody(name));
|
|---|
| 499 | }
|
|---|
| 500 | // `for-of` statement (in es5 mode replace with a normal for loop)
|
|---|
| 501 | forOf(nameOrPrefix, iterable, forBody, varKind = scope_1.varKinds.const) {
|
|---|
| 502 | const name = this._scope.toName(nameOrPrefix);
|
|---|
| 503 | if (this.opts.es5) {
|
|---|
| 504 | const arr = iterable instanceof code_1.Name ? iterable : this.var("_arr", iterable);
|
|---|
| 505 | return this.forRange("_i", 0, (0, code_1._) `${arr}.length`, (i) => {
|
|---|
| 506 | this.var(name, (0, code_1._) `${arr}[${i}]`);
|
|---|
| 507 | forBody(name);
|
|---|
| 508 | });
|
|---|
| 509 | }
|
|---|
| 510 | return this._for(new ForIter("of", varKind, name, iterable), () => forBody(name));
|
|---|
| 511 | }
|
|---|
| 512 | // `for-in` statement.
|
|---|
| 513 | // With option `ownProperties` replaced with a `for-of` loop for object keys
|
|---|
| 514 | forIn(nameOrPrefix, obj, forBody, varKind = this.opts.es5 ? scope_1.varKinds.var : scope_1.varKinds.const) {
|
|---|
| 515 | if (this.opts.ownProperties) {
|
|---|
| 516 | return this.forOf(nameOrPrefix, (0, code_1._) `Object.keys(${obj})`, forBody);
|
|---|
| 517 | }
|
|---|
| 518 | const name = this._scope.toName(nameOrPrefix);
|
|---|
| 519 | return this._for(new ForIter("in", varKind, name, obj), () => forBody(name));
|
|---|
| 520 | }
|
|---|
| 521 | // end `for` loop
|
|---|
| 522 | endFor() {
|
|---|
| 523 | return this._endBlockNode(For);
|
|---|
| 524 | }
|
|---|
| 525 | // `label` statement
|
|---|
| 526 | label(label) {
|
|---|
| 527 | return this._leafNode(new Label(label));
|
|---|
| 528 | }
|
|---|
| 529 | // `break` statement
|
|---|
| 530 | break(label) {
|
|---|
| 531 | return this._leafNode(new Break(label));
|
|---|
| 532 | }
|
|---|
| 533 | // `return` statement
|
|---|
| 534 | return(value) {
|
|---|
| 535 | const node = new Return();
|
|---|
| 536 | this._blockNode(node);
|
|---|
| 537 | this.code(value);
|
|---|
| 538 | if (node.nodes.length !== 1)
|
|---|
| 539 | throw new Error('CodeGen: "return" should have one node');
|
|---|
| 540 | return this._endBlockNode(Return);
|
|---|
| 541 | }
|
|---|
| 542 | // `try` statement
|
|---|
| 543 | try(tryBody, catchCode, finallyCode) {
|
|---|
| 544 | if (!catchCode && !finallyCode)
|
|---|
| 545 | throw new Error('CodeGen: "try" without "catch" and "finally"');
|
|---|
| 546 | const node = new Try();
|
|---|
| 547 | this._blockNode(node);
|
|---|
| 548 | this.code(tryBody);
|
|---|
| 549 | if (catchCode) {
|
|---|
| 550 | const error = this.name("e");
|
|---|
| 551 | this._currNode = node.catch = new Catch(error);
|
|---|
| 552 | catchCode(error);
|
|---|
| 553 | }
|
|---|
| 554 | if (finallyCode) {
|
|---|
| 555 | this._currNode = node.finally = new Finally();
|
|---|
| 556 | this.code(finallyCode);
|
|---|
| 557 | }
|
|---|
| 558 | return this._endBlockNode(Catch, Finally);
|
|---|
| 559 | }
|
|---|
| 560 | // `throw` statement
|
|---|
| 561 | throw(error) {
|
|---|
| 562 | return this._leafNode(new Throw(error));
|
|---|
| 563 | }
|
|---|
| 564 | // start self-balancing block
|
|---|
| 565 | block(body, nodeCount) {
|
|---|
| 566 | this._blockStarts.push(this._nodes.length);
|
|---|
| 567 | if (body)
|
|---|
| 568 | this.code(body).endBlock(nodeCount);
|
|---|
| 569 | return this;
|
|---|
| 570 | }
|
|---|
| 571 | // end the current self-balancing block
|
|---|
| 572 | endBlock(nodeCount) {
|
|---|
| 573 | const len = this._blockStarts.pop();
|
|---|
| 574 | if (len === undefined)
|
|---|
| 575 | throw new Error("CodeGen: not in self-balancing block");
|
|---|
| 576 | const toClose = this._nodes.length - len;
|
|---|
| 577 | if (toClose < 0 || (nodeCount !== undefined && toClose !== nodeCount)) {
|
|---|
| 578 | throw new Error(`CodeGen: wrong number of nodes: ${toClose} vs ${nodeCount} expected`);
|
|---|
| 579 | }
|
|---|
| 580 | this._nodes.length = len;
|
|---|
| 581 | return this;
|
|---|
| 582 | }
|
|---|
| 583 | // `function` heading (or definition if funcBody is passed)
|
|---|
| 584 | func(name, args = code_1.nil, async, funcBody) {
|
|---|
| 585 | this._blockNode(new Func(name, args, async));
|
|---|
| 586 | if (funcBody)
|
|---|
| 587 | this.code(funcBody).endFunc();
|
|---|
| 588 | return this;
|
|---|
| 589 | }
|
|---|
| 590 | // end function definition
|
|---|
| 591 | endFunc() {
|
|---|
| 592 | return this._endBlockNode(Func);
|
|---|
| 593 | }
|
|---|
| 594 | optimize(n = 1) {
|
|---|
| 595 | while (n-- > 0) {
|
|---|
| 596 | this._root.optimizeNodes();
|
|---|
| 597 | this._root.optimizeNames(this._root.names, this._constants);
|
|---|
| 598 | }
|
|---|
| 599 | }
|
|---|
| 600 | _leafNode(node) {
|
|---|
| 601 | this._currNode.nodes.push(node);
|
|---|
| 602 | return this;
|
|---|
| 603 | }
|
|---|
| 604 | _blockNode(node) {
|
|---|
| 605 | this._currNode.nodes.push(node);
|
|---|
| 606 | this._nodes.push(node);
|
|---|
| 607 | }
|
|---|
| 608 | _endBlockNode(N1, N2) {
|
|---|
| 609 | const n = this._currNode;
|
|---|
| 610 | if (n instanceof N1 || (N2 && n instanceof N2)) {
|
|---|
| 611 | this._nodes.pop();
|
|---|
| 612 | return this;
|
|---|
| 613 | }
|
|---|
| 614 | throw new Error(`CodeGen: not in block "${N2 ? `${N1.kind}/${N2.kind}` : N1.kind}"`);
|
|---|
| 615 | }
|
|---|
| 616 | _elseNode(node) {
|
|---|
| 617 | const n = this._currNode;
|
|---|
| 618 | if (!(n instanceof If)) {
|
|---|
| 619 | throw new Error('CodeGen: "else" without "if"');
|
|---|
| 620 | }
|
|---|
| 621 | this._currNode = n.else = node;
|
|---|
| 622 | return this;
|
|---|
| 623 | }
|
|---|
| 624 | get _root() {
|
|---|
| 625 | return this._nodes[0];
|
|---|
| 626 | }
|
|---|
| 627 | get _currNode() {
|
|---|
| 628 | const ns = this._nodes;
|
|---|
| 629 | return ns[ns.length - 1];
|
|---|
| 630 | }
|
|---|
| 631 | set _currNode(node) {
|
|---|
| 632 | const ns = this._nodes;
|
|---|
| 633 | ns[ns.length - 1] = node;
|
|---|
| 634 | }
|
|---|
| 635 | }
|
|---|
| 636 | exports.CodeGen = CodeGen;
|
|---|
| 637 | function addNames(names, from) {
|
|---|
| 638 | for (const n in from)
|
|---|
| 639 | names[n] = (names[n] || 0) + (from[n] || 0);
|
|---|
| 640 | return names;
|
|---|
| 641 | }
|
|---|
| 642 | function addExprNames(names, from) {
|
|---|
| 643 | return from instanceof code_1._CodeOrName ? addNames(names, from.names) : names;
|
|---|
| 644 | }
|
|---|
| 645 | function optimizeExpr(expr, names, constants) {
|
|---|
| 646 | if (expr instanceof code_1.Name)
|
|---|
| 647 | return replaceName(expr);
|
|---|
| 648 | if (!canOptimize(expr))
|
|---|
| 649 | return expr;
|
|---|
| 650 | return new code_1._Code(expr._items.reduce((items, c) => {
|
|---|
| 651 | if (c instanceof code_1.Name)
|
|---|
| 652 | c = replaceName(c);
|
|---|
| 653 | if (c instanceof code_1._Code)
|
|---|
| 654 | items.push(...c._items);
|
|---|
| 655 | else
|
|---|
| 656 | items.push(c);
|
|---|
| 657 | return items;
|
|---|
| 658 | }, []));
|
|---|
| 659 | function replaceName(n) {
|
|---|
| 660 | const c = constants[n.str];
|
|---|
| 661 | if (c === undefined || names[n.str] !== 1)
|
|---|
| 662 | return n;
|
|---|
| 663 | delete names[n.str];
|
|---|
| 664 | return c;
|
|---|
| 665 | }
|
|---|
| 666 | function canOptimize(e) {
|
|---|
| 667 | return (e instanceof code_1._Code &&
|
|---|
| 668 | e._items.some((c) => c instanceof code_1.Name && names[c.str] === 1 && constants[c.str] !== undefined));
|
|---|
| 669 | }
|
|---|
| 670 | }
|
|---|
| 671 | function subtractNames(names, from) {
|
|---|
| 672 | for (const n in from)
|
|---|
| 673 | names[n] = (names[n] || 0) - (from[n] || 0);
|
|---|
| 674 | }
|
|---|
| 675 | function not(x) {
|
|---|
| 676 | return typeof x == "boolean" || typeof x == "number" || x === null ? !x : (0, code_1._) `!${par(x)}`;
|
|---|
| 677 | }
|
|---|
| 678 | exports.not = not;
|
|---|
| 679 | const andCode = mappend(exports.operators.AND);
|
|---|
| 680 | // boolean AND (&&) expression with the passed arguments
|
|---|
| 681 | function and(...args) {
|
|---|
| 682 | return args.reduce(andCode);
|
|---|
| 683 | }
|
|---|
| 684 | exports.and = and;
|
|---|
| 685 | const orCode = mappend(exports.operators.OR);
|
|---|
| 686 | // boolean OR (||) expression with the passed arguments
|
|---|
| 687 | function or(...args) {
|
|---|
| 688 | return args.reduce(orCode);
|
|---|
| 689 | }
|
|---|
| 690 | exports.or = or;
|
|---|
| 691 | function mappend(op) {
|
|---|
| 692 | return (x, y) => (x === code_1.nil ? y : y === code_1.nil ? x : (0, code_1._) `${par(x)} ${op} ${par(y)}`);
|
|---|
| 693 | }
|
|---|
| 694 | function par(x) {
|
|---|
| 695 | return x instanceof code_1.Name ? x : (0, code_1._) `(${x})`;
|
|---|
| 696 | }
|
|---|
| 697 | //# sourceMappingURL=index.js.map |
|---|
