efront 3.34.11 → 3.35.0

package/coms/compile/autoenum.js

@@ -0,0 +1,179 @@
+var { skipAssignment, snapSentenceHead, EXPRESS, SCOPED, QUOTED, VALUE, STRAP, STAMP, number_reg, createString } = require("./common");
+var strings = require("../basic/strings");
+
+var createRefId = function (o) {
+    var ids = [], refs = [];
+    var g = o;
+    o.refs = refs;
+    while (o) {
+        if (o.type === SCOPED) {
+            if (o.entry !== '[') break;
+            var t = o.last;
+            if (!t) throw new Error("格式错误");
+            if (t.type === QUOTED) {
+                if (!t.length) {
+                    if (/\.|^#/.test(t.text)) {
+                        ids.push(`[${t.text}]`);
+                    }
+                    else {
+                        ids.push(strings.decode(t.text));
+                    }
+                }
+                else {
+                    ids.push("[*]");
+                    break;
+                }
+            }
+        }
+        else if (o.type === EXPRESS) {
+            var t = o.text.replace(/^\.\.\.|\.\.\.$/g, "").replace(/^[^\.\[]+/, '');
+            t.replace(/[^\.\[]+|\[[\s\S]*?\]/g, function (m) {
+                if (/^\[/.test(m)) {
+                    ids.push(strings.decode(m.slice(1, -1)));
+                }
+                else {
+                    ids.push("." + m);
+                }
+            })
+        }
+        else {
+            break;
+        }
+        var n = o.next;
+        refs.push(o);
+        if (!n) break;
+        if (n.type === EXPRESS && !/\.$/.test(o.text) && !/^[\.\[]/.test(n.text)) break;
+        o = n;
+    }
+    if (o && o.type === SCOPED && o.entry === '(') {
+        g.called = true;
+    }
+    return ids.join('');
+}
+var maplist = function (u) {
+    var map = Object.create(null);
+    for (var o of u) {
+        var r = createRefId(o);
+        if (!map[r]) {
+            map[r] = [];
+            map[r].wcount = 0;
+            map[r].ccount = 0;
+        }
+        map[r].push(o);
+        if (o.equal || o.kind) map[r].wcount++;
+        if (o.called) map[r].ccount++;
+    }
+    return map;
+}
+function createRefMap(scoped) {
+    var { used } = scoped;
+    var refs = Object.create(null);
+    for (var k in used) refs[k] = maplist(used[k]);
+    scoped.forEach(createRefMap);
+    return scoped.refs = refs;
+}
+function removeRefs(o) {
+    var refs = o.refs;
+    if (!refs || !refs.length) return;
+    var q = o.queue;
+    var start = q.indexOf(o) + 1;
+    var r = refs[refs.length - 1];
+    var end = q.indexOf(r) + 1;
+    q.splice(start, end - start);
+    o.next = r.next;
+    if (o.next) o.next.prev = o;
+}
+
+function inCondition(o) {
+    // 只检查一级
+    var incondition = false;
+    while (o && o.prev) {
+        o = snapSentenceHead(o);
+        var p = o.prev;
+        if (!p) break;
+        if (p.type === SCOPED) {
+            if (p.entry !== "(") break;
+            if (!p.prev) break;
+            var pp = p.prev;
+            if (pp.type === STRAP) {
+                if (/^(?:if|for|with)$/.test(pp.text)) {
+                    incondition = true;
+                    break;
+                }
+                if (/^(?:while)$/.test(pp.text)) {
+                    var ppp = pp.prev;
+                    if (!ppp || !ppp.prev) {
+                        incondition = true;
+                        break;
+                    }
+                    var pppp = ppp.prev;
+                    if (pppp.type === STRAP && pppp.text === "do") break;
+                    incondition = true;
+                    break;
+                }
+            }
+            break;
+        }
+        if (p.type === STAMP) {
+            if (p.text === ";") break;
+            o = p.prev;
+            continue;
+        }
+        break;
+    }
+    return incondition;
+
+}
+
+function enumref(scoped) {
+    if (scoped.isfunc) {
+        var { refs } = scoped;
+        for (var k in refs) {
+            var rs = refs[k];
+            for (var rk in rs) {
+                var os = rs[rk];
+                if (os.wcount !== 1 || os.length < 2) continue;
+                var eq = null;
+                loop: for (var o of os) {
+                    if (o.equal) {
+                        if (o.equal.text !== '=') break;
+                        if (o.queue.kind) break;
+                        if (o.queue !== scoped.body) break;
+                        if (inCondition(o)) break;
+                        o = o.equal.next;
+                        var n = skipAssignment(o);
+                        var exps = [];
+                        do {
+                            exps.push(o);
+                            o = o.next;
+                        } while (o && o !== n);
+                        if (exps.length !== 1) break loop;
+                        eq = exps[0];
+                        if (eq.type !== VALUE || !eq.isdigit) {
+                            eq = null;
+                        }
+                    }
+                    else {
+                        if (!eq) break;
+                        o.type = eq.type;
+                        o.isdigit = true;
+                        o.text = eq.text;
+                        removeRefs(o);
+                    }
+                }
+            }
+        }
+    }
+    scoped.forEach(enumref)
+}
+
+function atuoenum(scoped) {
+    createRefMap(scoped);
+    enumref(scoped);
+}
+var exports = module.exports = function main(code) {
+    atuoenum(code.scoped)
+    return code;
+}
+exports.createRefId = createRefId;
+exports.createRefMap = createRefMap;

package/coms/compile/autoenum_test.js

@@ -0,0 +1,17 @@
+var scanner2 = require("./scanner2");
+var { createString } = require("./common");
+var autoenum = require("./autoenum");
+var t = function (str, want) {
+    var code = scanner2(str)
+    var code = autoenum(code);
+    var result = createString(code);
+    assert(result, want);
+}
+t("var a=1;console.log(a)", "var a = 1; console.log(1)");
+t("a.b = 2;console.log(a.b)", "a.b = 2; console.log(2)");
+t("a/*a*/.b = 2;console.log(a.b)", "a/*a*/.b = 2; console.log(2)");
+t("a.b = 2;console.log(a/*aaaa*/.b)", "a.b = 2; console.log(2)");
+t("a.b = 2;console.log(/*bbbb*/a.b)", "a.b = 2; console.log(/*bbbb*/2)");
+t("var {a=1};console.log(a)", "var { a = 1 }; console.log(a)");
+t("if(c) a=1;console.log(a)", "if (c) a = 1; console.log(a)");
+// t(fs.readFileSync(path.join(__dirname,"../zimoli/spacechar_test.js")).toString())

package/coms/compile/autoeval.js

@@ -0,0 +1,50 @@
+var { skipAssignment, createString, QUOTED, STAMP, SCOPED, VALUE, SPACE, COMMENT, relink } = require("./common");
+
+var calculate = function (body) {
+    for (var cx = 0; cx < body.length; cx) {
+        var o = body[cx];
+        while (o && (o.type & (SPACE | COMMENT) || o.type === STAMP && /^[,;:]$/.test(o.text))) o = body[++cx];
+        if (!o) break;
+        var ox = cx;
+        var ex = skipAssignment(body, cx++);
+        cx = ex;
+        var ignore = false;
+        for (var cy = ox; cy < ex; cy++) {
+            var o = body[cy];
+            if (o.type & (SCOPED | QUOTED) && o.length) {
+                calculate(o);
+                if (o.type === SCOPED && o.entry === '(') {
+                    var p = o.prev;
+                    if (!p || p.type === STAMP || p.type === VALUE && p.isdigit) {
+                        if (o.last.type === VALUE && o.last.isdigit) {
+                            if ((o.first === o.last)) {
+                                o.type = VALUE;
+                                o.text = o.last.text;
+                                o.isdigit = true;
+                            }
+                            else if (o.first.next === o.last && o.first.type === STAMP && /^[+-~]+$/.test(o.first.text)) {
+                                o.type = VALUE;
+                                o.text = eval(o.first.text + o.last.text);
+                                o.isdigit = true;
+                            }
+                        }
+                    }
+                }
+            }
+            if (!(o.type & (STAMP | VALUE | SPACE | COMMENT))) ignore = true;
+            else if (o.type === VALUE && !o.isdigit) ignore = true;
+        }
+        if (ignore || ex - ox < 3) continue;
+        var o = body[ox];
+        o.text = eval(createString(body.slice(ox, ex)));
+        cx = ox + 1;
+        body.splice(cx, ex - cx);
+    }
+    relink(body);
+    return body;
+};
+
+module.exports = function autoeval(body) {
+    calculate(body);
+    return body;
+}

package/coms/compile/autoeval_test.js

@@ -0,0 +1,28 @@
+var { createString } = require("./common");
+var autoeval = require("./autoeval");
+var autoenum = require("./autoenum");
+var scanner2 = require("./scanner2");
+var t = function (str, want) {
+    var code = scanner2(str);
+    code = autoenum(code);
+    code = autoeval(code);
+    var result = createString(code);
+    assert(result, want);
+};
+var tf = function (fullpath) {
+    var data = fs.readFileSync(fullpath).toString()
+    t(data, data);
+}
+t("1+1", "2");
+t("1+3", "4");
+t("(1+3)", "4");
+t("(-1)*(1+3)", "-4");
+t("(-+-+-1)*(1+3)", "-4");
+t("(~1)*(1+3)", "-8");
+t("(1*-1)+(1+3)", "3");
+t("1+(1+3)", "5");
+t("a(1+3)", "a(4)");
+t("(1+3,5,3+4)", "(4, 5, 7)");
+t("(1>>3,5,3+4)", "(0, 5, 7)");
+t("a=1,b=2;(a|b)&c", "a = 1, b = 2; 3 & c");
+// tf(path.join(__dirname, "../zimoli/spacechar_test.js"))

package/coms/compile/autoiota.js

@@ -0,0 +1,121 @@
+var { skipAssignment, createString, createScoped, relink, STRAP, STAMP, SCOPED, EXPRESS, VALUE, SPACE, COMMENT } = require("./common");
+var backEach = require("../basic/backEach");
+var scanner2 = require("./scanner2");
+
+var removeNew = function (a, ai) {
+    var p = a.prev;
+    if (p && p.type === STRAP && p.text === 'new') {
+        ai = a.queue.lastIndexOf(p, ai);
+        a.queue.splice(ai, 1);
+    }
+    return ai;
+};
+var assignIota = function (v) {
+    var p = v.prev;
+    if (!p || p.type !== STAMP || p.text !== '=') return;
+    var pp = p.prev;
+    if (!pp || pp.type !== SCOPED || pp.entry !== '[') return;
+    var ppp = pp.prev;
+    if (ppp) if (ppp.type !== STRAP || !/^(var|let|const)$/.test(ppp.text)) return;
+    var o = skipAssignment(v);
+    if (v.next !== o) return;
+    var vmap = [];
+    var i = 0;
+    for (var va of v) {
+        if (va.type === STAMP && va.text === ',') {
+            i++;
+            continue;
+        }
+        if (!vmap[i]) vmap[i] = [];
+        vmap[i].push(va);
+    }
+    var ppmap = [];
+    var ppval = [];
+    var pptmp = null;
+    var i = 0;
+    for (var ppa of pp) {
+        if (ppa.type === SPACE || ppa.type === COMMENT) continue;
+        if (ppa.type === STAMP) {
+            if (ppa.text === ',') {
+                if (pptmp && pptmp.length) {
+                    ppval[i] = pptmp;
+                }
+                i++;
+                pptmp = null;
+                continue;
+            }
+            if (!pptmp && ppa.text === '=') {
+                pptmp = [];
+                continue;
+            }
+        }
+        if (pptmp) pptmp.push(pp);
+        else {
+            if (!ppmap[i]) ppmap[i] = [];
+            ppmap[i].push(ppa);
+        }
+    }
+    if (pptmp && pptmp.length) ppval[i] = pptmp;
+    var res = [];
+    ppmap.forEach((ppm, i) => {
+        if (!ppm) return;
+        var eq = { type: STAMP, text: '=' };
+        if (vmap[i]) res.push(...ppm, eq, ...vmap[i]);
+        else if (ppval[i]) res.push(...ppm, eq, ...ppval[i]);
+        else res.push(...ppm);
+        res.push({ type: STAMP, text: "," });
+    });
+    res.pop();
+    var ppi = p.queue.indexOf(pp);
+    var vi = p.queue.indexOf(v, ppi);
+    p.queue.splice(ppi, vi - ppi + 1, ...res);
+    relink(p.queue);
+}
+var arrayFillMap = function (a, i, as) {
+    if (a.text !== 'Array' || !a.next) return;
+    var n = a.next;
+    if (!n || n.type !== SCOPED || n.entry !== '(') return;
+    var nn = n.next;
+    if (!nn || nn.type !== EXPRESS || nn.text !== ".fill") return;
+    var nnn = nn.next;
+    if (!nnn || nnn.type !== SCOPED || nnn.entry !== '(') return;
+    var mn = nnn.next;
+    var f = n.first;
+    var mnn = mn.next;
+    if (!f || f.type !== VALUE || !f.isdigit ||
+        !mn || mn.type !== EXPRESS || mn.text !== '.map' ||
+        !mnn || mnn.type !== SCOPED || mnn.entry !== "(" ||
+        Object.keys(createScoped(mnn).used).length > 0) {
+        var ni = a.queue.indexOf(n);
+        var nnni = a.queue.indexOf(nnn, ni);
+        if (!f) {
+            a.queue.splice(n + 1, nnni - ni);
+            relink(a.queue);
+            return;
+        }
+        a.queue.splice(ni, nnni - ni);
+        nnn.unshift({ type: STAMP, text: ',' });
+        nnn.unshift.apply(nnn, n);
+        a.text = "ArrayFill";
+        as.splice(i, 1);
+        if (!this.envs.ArrayFill) this.envs.ArrayFill = true;
+        if (!this.used.ArrayFill) this.used.ArrayFill = [];
+        this.used.ArrayFill.push(a);
+        relink(nnn);
+        relink(a.queue);
+        return;
+    }
+    var ai = a.queue.indexOf(a);
+    ai = removeNew(a, ai);
+    var mnni = a.queue.indexOf(mnn, ai);
+    var value = createString(a.queue.splice(ai, mnni + 1 - ai));
+    as.splice(i, 1);
+    a.queue.splice(ai, 0, scanner2(JSON.stringify(eval(value)))[0]);
+    relink(a.queue);
+    assignIota(a.queue[ai]);
+};
+module.exports = function (body) {
+    var envs = body.envs;
+    if (envs.Array) backEach(body.used.Array, arrayFillMap, body);
+    return body;
+};

package/coms/compile/breakcode.js

@@ -0,0 +1,83 @@
+var scanner = require("./scanner");
+var keywords = require("./keywords");
+var strings = require("../basic/strings");
+var hasOwnProperty = {}.hasOwnProperty;
+var getReadableKey = function ($key, value) {
+    value = value.replace(/-->/g, '--\\>');
+    if (!/^[a-z][\w\$]*$/i.test($key)) {
+        $key = $key.replace(/[^\w\$]+/g, '_');
+        if ($key.length > 20) $key = $key.slice(0, 4) + $key.slice(-20);
+    }
+    $key = $key.replace(/(\d\.?)px/ig, "$1_px");
+    var id = 0;
+    while (($key in paramsMap) && paramsMap[$key] !== value || $key in keywords) {
+        $key = $key.replace(/\d+$/, '') + ++id;
+    }
+    if (!hasOwnProperty.call(paramsMap, $key)) {
+        paramsMap[$key] = value;
+    }
+    return $key;
+};
+var setMatchedConstString = function (k, p, f) {
+    if (/^(['"`])user?\s+(strict|asm|strip)\1$/i.test(k)) return k;
+    if (k.length < 3) return k;
+    k = strings.decode(k);
+    k = strings.encode(k);
+    var $key = "str_" + k.replace(/^(['"])([\s\S]*)\1$/g, '$2');
+    return getReadableKey($key, k);
+};
+var setMatchedConstRegExp = function (k, p, f) {
+    var $key = "reg_" + k.replace(/^\/([\s\S]*)\/(\w*)$/g, '$1_$2');
+    return getReadableKey($key, k);
+};
+var padStart = function (block) {
+    var m = module_string.charAt(block.start - 1);
+    return m && !/^[\[\(\s]$/.test(m) ? " " : '';
+};
+var padEnd = function (block) {
+    var m = module_string.charAt(block.end);
+    return m && !/^[\[\(\.\s\,\;\]\)]$/.test(m) ? " " : '';
+}
+var trimStringLiteral = function (block) {
+    var block_string = module_string.slice(block.start, block.end);
+    if (block.type === block.single_quote_scanner || block.type === block.double_quote_scanner) {
+        return padStart(block) + setMatchedConstString(block_string) + padEnd(block);
+    }
+    if (block.type === block.regexp_quote_scanner) {
+        return padStart(block) + setMatchedConstRegExp(block_string) + padEnd(block);
+    }
+    if (block.type === block.template_quote_scanner) {
+        var { start, end } = block;
+        if (block.children) {
+            var res = [];
+            for (var c of block.children) {
+                res.push(
+                    module_string.slice(start, c.start),
+                    trimStringLiteral(c).trim()
+                );
+                start = c.end;
+            }
+            res.push(module_string.slice(start, end));
+            return res.join('');
+        }
+    }
+    return block_string;
+};
+var paramsMap = Object.create(null);
+var module_string = '';
+function breakcode(data, args) {
+    if (!args) return [data];
+    module_string = data;
+    Object.keys(args).forEach(function (key) {
+        paramsMap[key] = true;
+    });
+    var code_blocks = scanner(module_string);
+    module_string = code_blocks.map(trimStringLiteral).join("");
+    var res = Object.keys(paramsMap).filter(k => !hasOwnProperty.call(args, k));
+    var val = res.map(k => paramsMap[k]);
+    paramsMap = Object.create(null);
+    data = module_string;
+    module_string = '';
+    return [data, res, val];
+}
+module.exports = breakcode;