diff options
Diffstat (limited to 'src/runtime')
| -rw-r--r-- | src/runtime/javascript/DEPRECATED.md | 7 | ||||
| -rw-r--r-- | src/runtime/typescript/.gitignore | 1 | ||||
| -rw-r--r-- | src/runtime/typescript/js/gflib.js | 1114 | ||||
| -rw-r--r-- | src/runtime/typescript/tsconfig.json | 4 |
4 files changed, 1124 insertions, 2 deletions
diff --git a/src/runtime/javascript/DEPRECATED.md b/src/runtime/javascript/DEPRECATED.md new file mode 100644 index 000000000..a4a8993c6 --- /dev/null +++ b/src/runtime/javascript/DEPRECATED.md @@ -0,0 +1,7 @@ +# Deprecation notice + +As of June 2019, this JavaScript version of the GF runtime is considered deprecated, +in favour of the TypeScript version in `../typescript/gflib.ts`. + +If you don't want/need TypeScript and are just looking for a ready-to-use JavaScript version, +see `../typescript/js/gflib.js` which is generated directly from the TypeScript version. diff --git a/src/runtime/typescript/.gitignore b/src/runtime/typescript/.gitignore deleted file mode 100644 index a6c7c2852..000000000 --- a/src/runtime/typescript/.gitignore +++ /dev/null @@ -1 +0,0 @@ -*.js diff --git a/src/runtime/typescript/js/gflib.js b/src/runtime/typescript/js/gflib.js new file mode 100644 index 000000000..04f78acd1 --- /dev/null +++ b/src/runtime/typescript/js/gflib.js @@ -0,0 +1,1114 @@ +var GFGrammar = (function () { + function GFGrammar(abstract, concretes) { + this.abstract = abstract; + this.concretes = concretes; + } + GFGrammar.prototype.translate = function (input, fromLang, toLang) { + var outputs = {}; + var fromConcs = this.concretes; + if (fromLang) { + fromConcs = {}; + fromConcs[fromLang] = this.concretes[fromLang]; + } + var toConcs = this.concretes; + if (toLang) { + toConcs = {}; + toConcs[toLang] = this.concretes[toLang]; + } + for (var c1 in fromConcs) { + var concrete = this.concretes[c1]; + var trees = concrete.parseString(input, this.abstract.startcat); + if (trees.length > 0) { + outputs[c1] = []; + for (var i in trees) { + outputs[c1][i] = {}; + for (var c2 in toConcs) { + outputs[c1][i][c2] = this.concretes[c2].linearize(trees[i]); + } + } + } + } + return outputs; + }; + return GFGrammar; +}()); +var Fun = (function () { + function Fun(name) { + var args = []; + for (var _i = 1; _i < arguments.length; _i++) { + args[_i - 1] = arguments[_i]; + } + this.name = name; + this.args = []; + for (var i = 1; i < args.length; i++) { + this.args[i - 1] = args[i]; + } + } + Fun.prototype.print = function () { + return this.show(0); + }; + Fun.prototype.show = function (prec) { + if (this.isMeta()) { + if (isUndefined(this.type)) { + return '?'; + } + else { + var s = '?:' + this.type; + if (prec > 0) { + s = '(' + s + ')'; + } + return s; + } + } + else { + var s = this.name; + var cs = this.args; + for (var i in cs) { + s += ' ' + (isUndefined(cs[i]) ? 'undefined' : cs[i].show(1)); + } + if (prec > 0 && cs.length > 0) { + s = '(' + s + ')'; + } + return s; + } + }; + Fun.prototype.getArg = function (i) { + return this.args[i]; + }; + Fun.prototype.setArg = function (i, c) { + this.args[i] = c; + }; + Fun.prototype.isMeta = function () { + return this.name == '?'; + }; + Fun.prototype.isComplete = function () { + if (this.isMeta()) { + return false; + } + else { + for (var i in this.args) { + if (!this.args[i].isComplete()) { + return false; + } + } + return true; + } + }; + Fun.prototype.isLiteral = function () { + return (/^[\"\-\d]/).test(this.name); + }; + Fun.prototype.isString = function () { + return (/^\".*\"$/).test(this.name); + }; + Fun.prototype.isInt = function () { + return (/^\-?\d+$/).test(this.name); + }; + Fun.prototype.isFloat = function () { + return (/^\-?\d*(\.\d*)?$/).test(this.name) && this.name != '.' && this.name != '-.'; + }; + Fun.prototype.isEqual = function (obj) { + if (this.name != obj.name) + return false; + for (var i in this.args) { + if (!this.args[i].isEqual(obj.args[i])) + return false; + } + return true; + }; + return Fun; +}()); +var GFAbstract = (function () { + function GFAbstract(startcat, types) { + this.startcat = startcat; + this.types = types; + } + GFAbstract.prototype.addType = function (fun, args, cat) { + this.types[fun] = new Type(args, cat); + }; + GFAbstract.prototype.getArgs = function (fun) { + return this.types[fun].args; + }; + GFAbstract.prototype.getCat = function (fun) { + return this.types[fun].cat; + }; + GFAbstract.prototype.annotate = function (tree, type) { + if (tree.name == '?') { + tree.type = type; + } + else { + var typ = this.types[tree.name]; + for (var i in tree.args) { + this.annotate(tree.args[i], typ.args[i]); + } + } + return tree; + }; + GFAbstract.prototype.handleLiterals = function (tree, type) { + if (tree.name != '?') { + if (type == 'String' || type == 'Int' || type == 'Float') { + tree.name = type + '_Literal_' + tree.name; + } + else { + var typ = this.types[tree.name]; + for (var i in tree.args) { + this.handleLiterals(tree.args[i], typ.args[i]); + } + } + } + return tree; + }; + GFAbstract.prototype.copyTree = function (x) { + var t = new Fun(x.name); + if (!isUndefined(x.type)) { + t.type = x.type; + } + var cs = x.args; + if (!isUndefined(cs)) { + for (var i = 0; i < cs.length; i++) { + t.setArg(i, this.copyTree(cs[i])); + } + } + return t; + }; + GFAbstract.prototype.parseTree = function (str, type) { + return this.annotate(this.parseTree_(str.match(/[\w\'\.\"]+|\(|\)|\?|\:/g), 0), type); + }; + GFAbstract.prototype.parseTree_ = function (tokens, prec) { + if (tokens.length == 0 || tokens[0] == ')') { + return null; + } + var t = tokens.shift(); + if (t == '(') { + var tree = this.parseTree_(tokens, 0); + tokens.shift(); + return tree; + } + else if (t == '?') { + return new Fun('?'); + } + else { + var tree = new Fun(t); + if (prec == 0) { + var c = void 0; + var i = void 0; + for (i = 0; (c = this.parseTree_(tokens, 1)) !== null; i++) { + tree.setArg(i, c); + } + } + return tree; + } + }; + return GFAbstract; +}()); +var Type = (function () { + function Type(args, cat) { + this.args = args; + this.cat = cat; + } + return Type; +}()); +var GFConcrete = (function () { + function GFConcrete(flags, productions, functions, sequences, startCats, totalFIds) { + this.flags = flags; + this.functions = functions; + this.startCats = startCats; + this.totalFIds = totalFIds; + this.pproductions = productions; + this.lproductions = {}; + var _loop_1 = function (fid0) { + var fid = parseInt(fid0); + var _loop_2 = function (i) { + var rule = productions[fid][i]; + if (rule.id == 'Apply') { + rule = rule; + var fun_1 = this_1.functions[rule.fun]; + var lproductions_1 = this_1.lproductions; + rule.fun = fun_1; + var register_1 = function (args, key, i) { + if (i < args.length) { + var c = 0; + var arg = args[i].fid; + for (var k in productions[arg]) { + var rule_1 = productions[arg][k]; + if (rule_1.id == 'Coerce') { + rule_1 = rule_1; + register_1(args, key + '_' + rule_1.arg, i + 1); + c++; + } + } + if (c == 0) { + register_1(args, key + '_' + arg, i + 1); + } + } + else { + var set = lproductions_1[key]; + if (set == null) { + set = []; + lproductions_1[key] = set; + } + set.push({ fun: fun_1, fid: fid }); + } + }; + register_1(rule.args, rule.fun.name, 0); + } + }; + for (var i in productions[fid]) { + _loop_2(i); + } + }; + var this_1 = this; + for (var fid0 in productions) { + _loop_1(fid0); + } + for (var _i = 0, functions_1 = functions; _i < functions_1.length; _i++) { + var fun = functions_1[_i]; + for (var j in fun.lins) { + fun.lins[j] = sequences[fun.lins[j]]; + } + } + } + GFConcrete.prototype.linearizeSyms = function (tree, tag) { + var res = []; + if (tree.isString()) { + var sym = new SymKS(tree.name); + sym.tag = tag; + res.push({ fid: -1, table: [[sym]] }); + } + else if (tree.isInt()) { + var sym = new SymKS(tree.name); + sym.tag = tag; + res.push({ fid: -2, table: [[sym]] }); + } + else if (tree.isFloat()) { + var sym = new SymKS(tree.name); + sym.tag = tag; + res.push({ fid: -3, table: [[sym]] }); + } + else if (tree.isMeta()) { + var cat = this.startCats[tree.type]; + var sym = new SymKS(tree.name); + sym.tag = tag; + for (var fid = cat.s; fid <= cat.e; fid++) { + res.push({ fid: fid, table: [[sym]] }); + } + } + else { + var cs_1 = []; + for (var i in tree.args) { + cs_1.push(this.linearizeSyms(tree.args[i], tag + '-' + i)[0]); + } + var key = tree.name; + for (var i in cs_1) { + key = key + '_' + cs_1[i].fid; + } + for (var i in this.lproductions[key]) { + var rule = this.lproductions[key][i]; + var row = { + fid: rule.fid, + table: [] + }; + var _loop_3 = function (j) { + var lin = rule.fun.lins[j]; + var toks = []; + row.table[j] = toks; + lin.forEach(function (sym0) { + switch (sym0.id) { + case 'Arg': + case 'Lit': { + var sym = sym0; + var ts = cs_1[sym.i].table[sym.label]; + for (var l in ts) { + toks.push(ts[l]); + } + break; + } + case 'KS': + case 'KP': { + var sym = sym0; + toks.push(sym.tagWith(tag)); + break; + } + } + }); + }; + for (var j in rule.fun.lins) { + _loop_3(j); + } + res.push(row); + } + } + return res; + }; + GFConcrete.prototype.syms2toks = function (syms) { + var ts = []; + var _loop_4 = function (i) { + var sym0 = syms[i]; + switch (sym0.id) { + case 'KS': { + var sym = sym0; + for (var j in sym.tokens) { + ts.push(sym.tokens[j].tagWith(sym.tag)); + } + break; + } + case 'KP': { + var sym_1 = sym0; + var addedAlt_1 = false; + if (i < syms.length - 1) { + var nextSym = syms[i + 1]; + if (nextSym.id == 'KS') { + var nextToken_1 = nextSym.tokens[0]; + sym_1.alts.forEach(function (alt) { + if (alt.prefixes.some(function (p) { return nextToken_1.startsWith(p); })) { + alt.tokens.forEach(function (symks) { + symks.tokens.forEach(function (t) { + ts.push(t.tagWith(sym_1.tag)); + }); + }); + addedAlt_1 = true; + return; + } + }); + } + } + if (addedAlt_1) + break; + sym_1.tokens.forEach(function (symks) { + symks.tokens.forEach(function (t) { + ts.push(t.tagWith(sym_1.tag)); + }); + }); + break; + } + } + }; + for (var i = 0; i < syms.length; i++) { + _loop_4(i); + } + return ts; + }; + GFConcrete.prototype.linearizeAll = function (tree) { + var _this = this; + return this.linearizeSyms(tree, '0').map(function (r) { + return _this.unlex(_this.syms2toks(r.table[0])); + }); + }; + GFConcrete.prototype.linearize = function (tree) { + var res = this.linearizeSyms(tree, '0'); + return this.unlex(this.syms2toks(res[0].table[0])); + }; + GFConcrete.prototype.tagAndLinearize = function (tree) { + var res = this.linearizeSyms(tree, '0'); + return this.syms2toks(res[0].table[0]); + }; + GFConcrete.prototype.unlex = function (ts) { + if (ts.length == 0) { + return ''; + } + var noSpaceAfter = /^[\(\-\[]/; + var noSpaceBefore = /^[\.\,\?\!\)\:\;\-\]]/; + var s = ''; + for (var i = 0; i < ts.length; i++) { + var t = ts[i]; + var after = i < ts.length - 1 ? ts[i + 1] : null; + s += t; + if (after != null + && !t.match(noSpaceAfter) + && !after.match(noSpaceBefore)) { + s += ' '; + } + } + return s; + }; + GFConcrete.prototype.tokenize = function (string) { + var inToken = false; + var start, end; + var tokens = []; + var i; + for (i = 0; i < string.length; i++) { + if (string.charAt(i) == ' ' + || string.charAt(i) == '\f' + || string.charAt(i) == '\n' + || string.charAt(i) == '\r' + || string.charAt(i) == '\t' + || string.charAt(i) == '\v' + || string.charAt(i) == String.fromCharCode(160)) { + if (inToken) { + end = i - 1; + inToken = false; + tokens.push(string.substr(start, end - start + 1)); + } + } + else { + if (!inToken) { + start = i; + inToken = true; + } + } + } + if (inToken) { + end = i - 1; + inToken = false; + tokens.push(string.substr(start, end - start + 1)); + } + return tokens; + }; + GFConcrete.prototype.parseString = function (string, cat) { + var tokens = this.tokenize(string); + var ps = new ParseState(this, cat); + for (var i in tokens) { + if (!ps.next(tokens[i])) + return []; + } + return ps.extractTrees(); + }; + GFConcrete.prototype.complete = function (input, cat) { + if (input == null) + input = ''; + var tokens = input.trim().split(' '); + for (var i = tokens.length - 1; i >= 0; i--) { + if (tokens[i] == '') { + tokens.splice(i, 1); + } + } + var current = tokens.pop(); + if (current == null) + current = ''; + var ps = new ParseState(this, cat); + var ps2 = new ParseState(this, cat); + for (var i = 0; i < tokens.length; i++) { + if (!ps.next(tokens[i])) { + return { 'consumed': [], 'suggestions': [] }; + } + ps2.next(tokens[i]); + } + if (ps2.next(current)) { + ps.next(current); + tokens.push(current); + current = ''; + } + var acc = ps.complete(current); + var suggs = []; + if (acc.value) { + acc.value.forEach(function (a) { + a.seq.forEach(function (s) { + if (s.tokens == null) + return; + switch (s.id) { + case 'KS': { + s.tokens.forEach(function (t) { + suggs.push(t); + }); + break; + } + case 'KP': { + s.tokens.forEach(function (symks) { + symks.tokens.forEach(function (t) { + suggs.push(t); + }); + }); + break; + } + } + }); + }); + } + return { 'consumed': tokens, 'suggestions': suggs }; + }; + return GFConcrete; +}()); +String.prototype.tagWith = function (tag) { + var s2 = this; + s2.tag = tag; + return s2; +}; +var Apply = (function () { + function Apply(fun, args) { + this.id = 'Apply'; + this.fun = fun; + this.args = args; + } + Apply.prototype.show = function (cat) { + var recStr = []; + recStr.push(cat, ' -> ', this.fun.name, ' [', this.args, ']'); + return recStr.join(''); + }; + Apply.prototype.isEqual = function (obj) { + if (this.id != obj.id || this.fun != obj.fun || this.args.length != obj.args.length) + return false; + for (var i in this.args) { + if (this.args[i] != obj.args[i]) + return false; + } + return true; + }; + return Apply; +}()); +var Coerce = (function () { + function Coerce(arg) { + this.id = 'Coerce'; + this.arg = arg; + } + Coerce.prototype.show = function (cat) { + var recStr = []; + recStr.push(cat, ' -> _ [', this.arg, ']'); + return recStr.join(''); + }; + return Coerce; +}()); +var PArg = (function () { + function PArg() { + var hypos = []; + for (var _i = 0; _i < arguments.length; _i++) { + hypos[_i] = arguments[_i]; + } + this.fid = hypos[hypos.length - 1]; + if (hypos.length > 1) + this.hypos = hypos.slice(0, hypos.length - 1); + } + return PArg; +}()); +var Const = (function () { + function Const(lit, toks) { + this.id = 'Const'; + this.lit = lit; + this.toks = toks; + } + Const.prototype.show = function (cat) { + var recStr = []; + recStr.push(cat, ' -> ', this.lit.print()); + return recStr.join(''); + }; + Const.prototype.isEqual = function (obj) { + if (this.id != obj.id || this.lit.isEqual(obj.lit) || this.toks.length != obj.toks.length) + return false; + for (var i in this.toks) { + if (this.toks[i] != obj.toks[i]) + return false; + } + return true; + }; + return Const; +}()); +var CncFun = (function () { + function CncFun(name, lins) { + this.name = name; + this.lins = lins; + } + return CncFun; +}()); +var SymCat = (function () { + function SymCat(i, label) { + this.id = 'Arg'; + this.i = i; + this.label = label; + } + SymCat.prototype.show = function () { + var argStr = []; + argStr.push(this.i, this.label); + return argStr.join('.'); + }; + return SymCat; +}()); +var SymKS = (function () { + function SymKS() { + var tokens = []; + for (var _i = 0; _i < arguments.length; _i++) { + tokens[_i] = arguments[_i]; + } + this.id = 'KS'; + this.tokens = tokens; + } + SymKS.prototype.show = function () { + var terminalStr = []; + terminalStr.push('"', this.tokens, '"'); + return terminalStr.join(''); + }; + SymKS.prototype.tagWith = function (tag) { + var s = new SymKS(); + s.tokens = this.tokens.slice(); + s.tag = tag; + return s; + }; + return SymKS; +}()); +var SymKP = (function () { + function SymKP(tokens, alts) { + this.id = 'KP'; + this.tokens = tokens; + this.alts = alts; + } + SymKP.prototype.show = function () { + var terminalStr = []; + terminalStr.push('"', this.tokens, '"'); + return terminalStr.join(''); + }; + SymKP.prototype.tagWith = function (tag) { + var s = new SymKP(this.tokens.slice(), this.alts.slice()); + s.tag = tag; + return s; + }; + return SymKP; +}()); +var Alt = (function () { + function Alt(tokens, prefixes) { + this.tokens = tokens; + this.prefixes = prefixes; + } + return Alt; +}()); +var SymLit = (function () { + function SymLit(i, label) { + this.id = 'Lit'; + this.i = i; + this.label = label; + } + SymLit.prototype.getId = function () { + return this.id; + }; + SymLit.prototype.show = function () { + var argStr = []; + argStr.push(this.i, this.label); + return argStr.join('.'); + }; + return SymLit; +}()); +var Trie = (function () { + function Trie() { + this.value = null; + this.items = {}; + } + Trie.prototype.insertChain = function (keys, obj) { + var node = this; + keys.forEach(function (key) { + var nnode = node.items[key]; + if (nnode == null) { + nnode = new Trie(); + node.items[key] = nnode; + } + node = nnode; + }); + node.value = obj; + }; + Trie.prototype.insertChain1 = function (keys, obj) { + var node = this; + keys.forEach(function (key) { + var nnode = node.items[key]; + if (nnode == null) { + nnode = new Trie(); + node.items[key] = nnode; + } + node = nnode; + }); + if (node.value == null) + node.value = [obj]; + else + node.value.push(obj); + }; + Trie.prototype.lookup = function (key) { + return this.items[key]; + }; + Trie.prototype.isEmpty = function () { + if (this.value != null) + return false; + for (var _ in this.items) { + return false; + } + return true; + }; + return Trie; +}()); +var ParseState = (function () { + function ParseState(concrete, startCat) { + this.concrete = concrete; + this.startCat = startCat; + this.items = new Trie(); + this.chart = new Chart(concrete); + var items = []; + var fids = concrete.startCats[startCat]; + if (fids != null) { + var fid = void 0; + for (fid = fids.s; fid <= fids.e; fid++) { + var exProds = this.chart.expandForest(fid); + for (var j in exProds) { + var rule = exProds[j]; + var fun = rule.fun; + for (var lbl in fun.lins) { + items.push(new ActiveItem(0, 0, rule.fun, fun.lins[lbl], rule.args, fid, parseInt(lbl))); + } + } + } + } + this.items.insertChain([], items); + } + ParseState.prototype.next = function (token) { + var acc = this.items.lookup(token); + if (acc == null) { + acc = new Trie(); + } + this.process(this.items.value, function (fid) { + switch (fid) { + case -1: + return new Const(new Fun('"' + token + '"'), [token]); + case -2: { + var x = parseInt(token, 10); + if (token == '0' || (x != 0 && !isNaN(x))) + return new Const(new Fun(token), [token]); + else + return null; + } + case -3: { + var x = parseFloat(token); + if (token == '0' || token == '0.0' || (x != 0 && !isNaN(x))) + return new Const(new Fun(token), [token]); + else + return null; + } + } + return null; + }, function (tokens, item) { + if (tokens[0] == token) { + var tokens1 = []; + for (var i = 1; i < tokens.length; i++) { + tokens1[i - 1] = tokens[i]; + } + acc.insertChain1(tokens1, item); + } + }); + this.items = acc; + this.chart.shift(); + return !this.items.isEmpty(); + }; + ParseState.prototype.complete = function (currentToken) { + var acc = this.items.lookup(currentToken); + if (acc == null) + acc = new Trie(); + this.process(this.items.value, function (_fid) { + return null; + }, function (tokens, item) { + if (currentToken == '' || tokens[0].indexOf(currentToken) == 0) { + var tokens1 = []; + for (var i = 1; i < tokens.length; i++) { + tokens1[i - 1] = tokens[i]; + } + acc.insertChain1(tokens1, item); + } + }); + return acc; + }; + ParseState.prototype.extractTrees = function () { + this.process(this.items.value, function (_fid) { + return null; + }, function (_tokens, _item) { + }); + var totalFIds = this.concrete.totalFIds; + var forest = this.chart.forest; + function go(fid) { + if (fid < totalFIds) { + return [new Fun('?')]; + } + else { + var trees_1 = []; + var rules = forest[fid]; + for (var j in rules) { + var rule = rules[j]; + if (rule.id == 'Const') { + trees_1.push(rule.lit); + } + else { + rule = rule; + var arg_ix = []; + var arg_ts = []; + for (var k in rule.args) { + arg_ix[k] = 0; + arg_ts[k] = go(rule.args[k].fid); + } + while (true) { + var t = new Fun(rule.fun.name); + for (var k = 0; k < arg_ts.length; k++) { + t.setArg(k, arg_ts[k][arg_ix[k]]); + } + trees_1.push(t); + var i = 0; + while (i < arg_ts.length) { + arg_ix[i]++; + if (arg_ix[i] < arg_ts[i].length) + break; + arg_ix[i] = 0; + i++; + } + if (i >= arg_ts.length) + break; + } + } + } + return trees_1; + } + } + var trees = []; + var fids = this.concrete.startCats[this.startCat]; + if (fids != null) { + var _loop_5 = function (fid0) { + var labels = {}; + var rules = this_2.chart.expandForest(fid0); + rules.forEach(function (rule) { + for (var lbl in rule.fun.lins) { + labels[lbl] = true; + } + }); + for (var lbl0 in labels) { + var lbl = parseInt(lbl0); + var fid = this_2.chart.lookupPC(fid0, lbl, 0); + var arg_ts = go(fid); + for (var i in arg_ts) { + var isMember = false; + for (var j in trees) { + if (arg_ts[i].isEqual(trees[j])) { + isMember = true; + break; + } + } + if (!isMember) + trees.push(arg_ts[i]); + } + } + }; + var this_2 = this; + for (var fid0 = fids.s; fid0 <= fids.e; fid0++) { + _loop_5(fid0); + } + } + return trees; + }; + ParseState.prototype.process = function (agenda, literalCallback, tokenCallback) { + if (agenda != null) { + var _loop_6 = function () { + var item = agenda.pop(); + var lin = item.seq; + if (item.dot < lin.length) { + var sym0 = lin[item.dot]; + switch (sym0.id) { + case 'Arg': { + var sym = sym0; + var fid = item.args[sym.i].fid; + var label = sym.label; + var items = this_3.chart.lookupAC(fid, label); + if (items == null) { + var rules = this_3.chart.expandForest(fid); + for (var j in rules) { + var rule = rules[j]; + agenda.push(new ActiveItem(this_3.chart.offset, 0, rule.fun, rule.fun.lins[label], rule.args, fid, label)); + } + this_3.chart.insertAC(fid, label, [item]); + } + else { + var isMember = false; + for (var j in items) { + if (items[j].isEqual(item)) { + isMember = true; + break; + } + } + if (!isMember) { + items.push(item); + var fid2 = this_3.chart.lookupPC(fid, label, this_3.chart.offset); + if (fid2 != null) { + agenda.push(item.shiftOverArg(sym.i, fid2)); + } + } + } + break; + } + case 'KS': { + var sym = sym0; + tokenCallback(sym.tokens, item.shiftOverTokn()); + break; + } + case 'KP': { + var sym = sym0; + var pitem_1 = item.shiftOverTokn(); + sym.tokens.forEach(function (symks) { + tokenCallback(symks.tokens, pitem_1); + }); + sym.alts.forEach(function (alt) { + alt.tokens.forEach(function (symks) { + tokenCallback(symks.tokens, pitem_1); + }); + }); + break; + } + case 'Lit': { + var sym = sym0; + var fid = item.args[sym.i].fid; + var rules = this_3.chart.forest[fid]; + if (rules != null) { + tokenCallback(rules[0].toks, item.shiftOverTokn()); + } + else { + var rule = literalCallback(fid); + if (rule != null) { + fid = this_3.chart.nextId++; + this_3.chart.forest[fid] = [rule]; + tokenCallback(rule.toks, item.shiftOverArg(sym.i, fid)); + } + } + break; + } + } + } + else { + var fid_1 = this_3.chart.lookupPC(item.fid, item.lbl, item.offset); + if (fid_1 == null) { + fid_1 = this_3.chart.nextId++; + var items = this_3.chart.lookupACo(item.offset, item.fid, item.lbl); + if (items != null) { + items.forEach(function (pitem) { + var i = pitem.seq[pitem.dot].i; + agenda.push(pitem.shiftOverArg(i, fid_1)); + }); + } + this_3.chart.insertPC(item.fid, item.lbl, item.offset, fid_1); + this_3.chart.forest[fid_1] = [new Apply(item.fun, item.args)]; + } + else { + var labels = this_3.chart.labelsAC(fid_1); + if (labels != null) { + for (var lbl in labels) { + agenda.push(new ActiveItem(this_3.chart.offset, 0, item.fun, item.fun.lins[lbl], item.args, fid_1, parseInt(lbl))); + } + } + var rules = this_3.chart.forest[fid_1]; + var rule_2 = new Apply(item.fun, item.args); + var isMember_1 = false; + rules.forEach(function (rule1) { + if (rule1.isEqual(rule_2)) + isMember_1 = true; + }); + if (!isMember_1) + rules.push(rule_2); + } + } + }; + var this_3 = this; + while (agenda.length > 0) { + _loop_6(); + } + } + }; + return ParseState; +}()); +var Chart = (function () { + function Chart(concrete) { + this.active = {}; + this.actives = []; + this.passive = {}; + this.forest = {}; + this.nextId = concrete.totalFIds; + this.offset = 0; + for (var fid in concrete.pproductions) { + this.forest[fid] = concrete.pproductions[fid]; + } + } + Chart.prototype.lookupAC = function (fid, label) { + var tmp = this.active[fid]; + if (tmp == null) + return null; + return tmp[label]; + }; + Chart.prototype.lookupACo = function (offset, fid, label) { + var tmp; + if (offset == this.offset) + tmp = this.active[fid]; + else + tmp = this.actives[offset][fid]; + if (tmp == null) + return null; + return tmp[label]; + }; + Chart.prototype.labelsAC = function (fid) { + return this.active[fid]; + }; + Chart.prototype.insertAC = function (fid, label, items) { + var tmp = this.active[fid]; + if (tmp == null) { + tmp = {}; + this.active[fid] = tmp; + } + tmp[label] = items; + }; + Chart.prototype.lookupPC = function (fid, label, offset) { + var key = fid + '.' + label + '-' + offset; + return this.passive[key]; + }; + Chart.prototype.insertPC = function (fid1, label, offset, fid2) { + var key = fid1 + '.' + label + '-' + offset; + this.passive[key] = fid2; + }; + Chart.prototype.shift = function () { + this.actives.push(this.active); + this.active = {}; + this.passive = {}; + this.offset++; + }; + Chart.prototype.expandForest = function (fid) { + var rules = []; + var forest = this.forest; + var go = function (rules0) { + for (var i in rules0) { + var rule = rules0[i]; + switch (rule.id) { + case 'Apply': + rules.push(rule); + break; + case 'Coerce': + go(forest[rule.arg]); + break; + } + } + }; + go(this.forest[fid]); + return rules; + }; + return Chart; +}()); +var ActiveItem = (function () { + function ActiveItem(offset, dot, fun, seq, args, fid, lbl) { + this.offset = offset; + this.dot = dot; + this.fun = fun; + this.seq = seq; + this.args = args; + this.fid = fid; + this.lbl = lbl; + } + ActiveItem.prototype.isEqual = function (obj) { + return (this.offset == obj.offset && + this.dot == obj.dot && + this.fun == obj.fun && + this.seq == obj.seq && + this.args == obj.args && + this.fid == obj.fid && + this.lbl == obj.lbl); + }; + ActiveItem.prototype.shiftOverArg = function (i, fid) { + var nargs = []; + for (var k in this.args) { + nargs[k] = this.args[k]; + } + nargs[i] = new PArg(fid); + return new ActiveItem(this.offset, this.dot + 1, this.fun, this.seq, nargs, this.fid, this.lbl); + }; + ActiveItem.prototype.shiftOverTokn = function () { + return new ActiveItem(this.offset, this.dot + 1, this.fun, this.seq, this.args, this.fid, this.lbl); + }; + return ActiveItem; +}()); +function isUndefined(a) { + return typeof a == 'undefined'; +} +Object.defineProperty(String.prototype, 'startsWith', { + value: function (search, pos) { + pos = !pos || pos < 0 ? 0 : +pos; + return this.substring(pos, pos + search.length) === search; + } +}); diff --git a/src/runtime/typescript/tsconfig.json b/src/runtime/typescript/tsconfig.json index 9a6cb7ac6..ab8f984db 100644 --- a/src/runtime/typescript/tsconfig.json +++ b/src/runtime/typescript/tsconfig.json @@ -2,7 +2,9 @@ "compilerOptions": { "module": "none", "target": "es3", - "noImplicitAny": true + "noImplicitAny": true, + "removeComments": true, + "outDir": "js" }, "compileOnSave": true } |