3547 lines
131 KiB
JavaScript
3547 lines
131 KiB
JavaScript
var __extends = (this && this.__extends) || (function () {
|
|
var extendStatics = function (d, b) {
|
|
extendStatics = Object.setPrototypeOf ||
|
|
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
|
|
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
|
|
return extendStatics(d, b);
|
|
};
|
|
return function (d, b) {
|
|
extendStatics(d, b);
|
|
function __() { this.constructor = d; }
|
|
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
|
|
};
|
|
})();
|
|
/*
|
|
This file is part of »bacterio-plankton:base«.
|
|
|
|
Copyright 2016-2021 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
|
|
<info@greenscale.de>
|
|
|
|
»bacterio-plankton:base« is free software: you can redistribute it and/or modify
|
|
it under the terms of the GNU Lesser General Public License as published by
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
»bacterio-plankton:base« is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU Lesser General Public License for more details.
|
|
|
|
You should have received a copy of the GNU Lesser General Public License
|
|
along with »bacterio-plankton:base«. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
// }
|
|
/*
|
|
This file is part of »bacterio-plankton:base«.
|
|
|
|
Copyright 2016-2021 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
|
|
<info@greenscale.de>
|
|
|
|
»bacterio-plankton:base« is free software: you can redistribute it and/or modify
|
|
it under the terms of the GNU Lesser General Public License as published by
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
»bacterio-plankton:base« is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU Lesser General Public License for more details.
|
|
|
|
You should have received a copy of the GNU Lesser General Public License
|
|
along with »bacterio-plankton:base«. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
/*export*/ function pseudopointer_null() {
|
|
return {
|
|
"value": null
|
|
};
|
|
}
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
/*export*/ function pseudopointer_make(value) {
|
|
return {
|
|
"value": value
|
|
};
|
|
}
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
/*export*/ function pseudopointer_isset(pseudopointer) {
|
|
return (pseudopointer.value != null);
|
|
}
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
/*export*/ function pseudopointer_read(pseudopointer) {
|
|
if (pseudopointer.value != null) {
|
|
return pseudopointer.value;
|
|
}
|
|
else {
|
|
var message = "nullpointer dereferencation";
|
|
throw (new Error(message));
|
|
}
|
|
}
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
/*export*/ function pseudopointer_write(pseudopointer, value) {
|
|
pseudopointer.value = value;
|
|
}
|
|
/*
|
|
This file is part of »bacterio-plankton:base«.
|
|
|
|
Copyright 2016-2021 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
|
|
<info@greenscale.de>
|
|
|
|
»bacterio-plankton:base« is free software: you can redistribute it and/or modify
|
|
it under the terms of the GNU Lesser General Public License as published by
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
»bacterio-plankton:base« is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU Lesser General Public License for more details.
|
|
|
|
You should have received a copy of the GNU Lesser General Public License
|
|
along with »bacterio-plankton:base«. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
;
|
|
var lib_base;
|
|
(function (lib_base) {
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
function environment() {
|
|
var entries = [
|
|
{
|
|
"id": "web",
|
|
"name": "Web",
|
|
"predicate": function () { return (typeof (document) !== "undefined"); },
|
|
},
|
|
{
|
|
"id": "node",
|
|
"name": "Node.js",
|
|
"predicate": function () { return (typeof (process) !== "undefined"); },
|
|
},
|
|
{
|
|
"id": "rhino",
|
|
"name": "Rhino",
|
|
"predicate": function () { return (typeof (java) !== "undefined"); },
|
|
},
|
|
{
|
|
"id": "webworker",
|
|
"name": "WebWorker",
|
|
"predicate": function () { return (typeof (self["WorkerNavigator"]) !== "undefined"); }
|
|
}
|
|
];
|
|
var id;
|
|
var found = entries.some(function (entry) {
|
|
if (entry.predicate()) {
|
|
id = entry.id;
|
|
return true;
|
|
}
|
|
else {
|
|
return false;
|
|
}
|
|
});
|
|
if (found) {
|
|
return id;
|
|
}
|
|
else {
|
|
throw (new Error("unknown environment"));
|
|
}
|
|
}
|
|
lib_base.environment = environment;
|
|
})(lib_base || (lib_base = {}));
|
|
/*
|
|
This file is part of »bacterio-plankton:base«.
|
|
|
|
Copyright 2016-2021 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
|
|
<info@greenscale.de>
|
|
|
|
»bacterio-plankton:base« is free software: you can redistribute it and/or modify
|
|
it under the terms of the GNU Lesser General Public License as published by
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
»bacterio-plankton:base« is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU Lesser General Public License for more details.
|
|
|
|
You should have received a copy of the GNU Lesser General Public License
|
|
along with »bacterio-plankton:base«. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
var instance_verbosity = 0;
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
function instance_collate(value1, value2) {
|
|
if (typeof (value1) === "object") {
|
|
if (value1 == null) {
|
|
return (value2 == null);
|
|
}
|
|
else {
|
|
if ("_collate" in value1) {
|
|
return value1["_collate"](value2);
|
|
}
|
|
else {
|
|
throw (new Error("[collate]" + " " + "object has no such method"));
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
if (instance_verbosity >= 1) {
|
|
lib_log.warn("[collate]" + " " + "primitive value; using default implementation");
|
|
}
|
|
return (value1 === value2);
|
|
}
|
|
}
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
function instance_compare(value1, value2) {
|
|
if (typeof (value1) === "object") {
|
|
if ("_compare" in value1) {
|
|
return value1["_compare"](value2);
|
|
}
|
|
else {
|
|
throw (new Error("[compare]" + " " + "object has no such method"));
|
|
}
|
|
}
|
|
else {
|
|
if (instance_verbosity >= 1) {
|
|
lib_log.warn("[compare]" + " " + "primitive value; using default implementation");
|
|
}
|
|
return (value1 <= value2);
|
|
}
|
|
}
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
function instance_clone(value) {
|
|
if (typeof (value) === "object") {
|
|
if ("_clone" in value) {
|
|
return value["_clone"]();
|
|
}
|
|
else {
|
|
throw (new Error("[clone]" + " " + "object has no such method"));
|
|
}
|
|
}
|
|
else {
|
|
if (instance_verbosity >= 1) {
|
|
lib_log.warn("[clone]" + " " + "primitive value; using default implementation");
|
|
}
|
|
return value;
|
|
}
|
|
}
|
|
/**
|
|
* @desc the ability to generate a string out of the element, which identifies it to a high degree
|
|
* @author fenris
|
|
*/
|
|
function instance_hash(value) {
|
|
if (typeof (value) === "object") {
|
|
if ("_hash" in value) {
|
|
return value["_hash"]();
|
|
}
|
|
else {
|
|
throw (new Error("[hash]" + " " + "object has no such method"));
|
|
}
|
|
}
|
|
else {
|
|
if (instance_verbosity >= 1) {
|
|
lib_log.warn("[hash]" + " " + "primitive value; using default implementation");
|
|
}
|
|
return String(value);
|
|
}
|
|
}
|
|
/**
|
|
* @desc the ability to map the element to a textual representation (most likely not injective)
|
|
* @author fenris
|
|
*/
|
|
function instance_show(value) {
|
|
if (typeof (value) === "object") {
|
|
if (value == null) {
|
|
return "NULL";
|
|
}
|
|
else {
|
|
if ("_show" in value) {
|
|
return value["_show"]();
|
|
}
|
|
else {
|
|
// throw (new Error("[show]" + " " + "object has no such method"));
|
|
return JSON.stringify(value);
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
if (instance_verbosity >= 1) {
|
|
lib_log.warn("[show]" + " " + "primitive value; using default implementation");
|
|
}
|
|
return String(value);
|
|
}
|
|
}
|
|
/*
|
|
This file is part of »bacterio-plankton:base«.
|
|
|
|
Copyright 2016-2021 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
|
|
<info@greenscale.de>
|
|
|
|
»bacterio-plankton:base« is free software: you can redistribute it and/or modify
|
|
it under the terms of the GNU Lesser General Public License as published by
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
»bacterio-plankton:base« is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU Lesser General Public License for more details.
|
|
|
|
You should have received a copy of the GNU Lesser General Public License
|
|
along with »bacterio-plankton:base«. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
/**
|
|
* @todo outsource to dedicated plankton-lib
|
|
*/
|
|
var lib_log;
|
|
(function (lib_log) {
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
function log() {
|
|
var args = [];
|
|
for (var _i = 0; _i < arguments.length; _i++) {
|
|
args[_i] = arguments[_i];
|
|
}
|
|
/*window.*/ console.log.apply(console, args);
|
|
}
|
|
lib_log.log = log;
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
function info() {
|
|
var args = [];
|
|
for (var _i = 0; _i < arguments.length; _i++) {
|
|
args[_i] = arguments[_i];
|
|
}
|
|
/*window.*/ console.info.apply(console, args);
|
|
}
|
|
lib_log.info = info;
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
function warn() {
|
|
var args = [];
|
|
for (var _i = 0; _i < arguments.length; _i++) {
|
|
args[_i] = arguments[_i];
|
|
}
|
|
/*window.*/ console.warn.apply(console, args);
|
|
}
|
|
lib_log.warn = warn;
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
function error() {
|
|
var args = [];
|
|
for (var _i = 0; _i < arguments.length; _i++) {
|
|
args[_i] = arguments[_i];
|
|
}
|
|
/*window.*/ console.error.apply(console, args);
|
|
}
|
|
lib_log.error = error;
|
|
})(lib_log || (lib_log = {}));
|
|
/*
|
|
This file is part of »bacterio-plankton:base«.
|
|
|
|
Copyright 2016-2021 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
|
|
<info@greenscale.de>
|
|
|
|
»bacterio-plankton:base« is free software: you can redistribute it and/or modify
|
|
it under the terms of the GNU Lesser General Public License as published by
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
»bacterio-plankton:base« is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU Lesser General Public License for more details.
|
|
|
|
You should have received a copy of the GNU Lesser General Public License
|
|
along with »bacterio-plankton:base«. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
/**
|
|
* @author frac
|
|
*/
|
|
var class_observer = /** @class */ (function () {
|
|
/**
|
|
* @author frac
|
|
*/
|
|
function class_observer() {
|
|
this.counter = 0;
|
|
this.actions = {};
|
|
this.buffer = [];
|
|
}
|
|
/**
|
|
* @author frac
|
|
*/
|
|
class_observer.prototype.empty = function () {
|
|
return (Object.keys(this.actions).length == 0);
|
|
};
|
|
/**
|
|
* @author frac
|
|
*/
|
|
class_observer.prototype.flush = function () {
|
|
this.actions = {};
|
|
};
|
|
/**
|
|
* @author frac
|
|
*/
|
|
class_observer.prototype.set = function (id, action) {
|
|
this.actions[id] = action;
|
|
};
|
|
/**
|
|
* @author frac
|
|
*/
|
|
class_observer.prototype.del = function (id) {
|
|
delete this.actions[id];
|
|
};
|
|
/**
|
|
* @author frac
|
|
*/
|
|
class_observer.prototype.add = function (action) {
|
|
this.set((this.counter++).toString(), action);
|
|
};
|
|
/**
|
|
* @author frac
|
|
*/
|
|
class_observer.prototype.notify = function (information, delayed) {
|
|
var _this = this;
|
|
if (information === void 0) { information = {}; }
|
|
if (delayed === void 0) { delayed = false; }
|
|
if (delayed) {
|
|
this.buffer.push(information);
|
|
}
|
|
else {
|
|
Object.keys(this.actions).forEach(function (id) { return _this.actions[id](information); });
|
|
}
|
|
};
|
|
/**
|
|
* @author frac
|
|
*/
|
|
class_observer.prototype.rollout = function () {
|
|
var _this = this;
|
|
this.buffer.forEach(function (information) { return _this.notify(information, false); });
|
|
this.buffer = [];
|
|
};
|
|
return class_observer;
|
|
}());
|
|
/**
|
|
* @author frac
|
|
*/
|
|
/*
|
|
export interface interface_readable<type_value> {
|
|
|
|
|**
|
|
* @author frac
|
|
*|
|
|
read() : type_executor<type_value, Error>;
|
|
|
|
}
|
|
*/
|
|
/**
|
|
* @author frac
|
|
*/
|
|
/*
|
|
export interface interface_writeable<type_value> {
|
|
|
|
|**
|
|
* @author frac
|
|
*|
|
|
write(value : type_value) : type_executor<void, Error>;
|
|
|
|
}
|
|
*/
|
|
/*
|
|
This file is part of »bacterio-plankton:base«.
|
|
|
|
Copyright 2016-2021 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
|
|
<info@greenscale.de>
|
|
|
|
»bacterio-plankton:base« is free software: you can redistribute it and/or modify
|
|
it under the terms of the GNU Lesser General Public License as published by
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
»bacterio-plankton:base« is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU Lesser General Public License for more details.
|
|
|
|
You should have received a copy of the GNU Lesser General Public License
|
|
along with »bacterio-plankton:base«. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
var lib_maybe;
|
|
(function (lib_maybe) {
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
function make_nothing() {
|
|
return {
|
|
"kind": "nothing",
|
|
"parameters": {}
|
|
};
|
|
}
|
|
lib_maybe.make_nothing = make_nothing;
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
function make_just(value) {
|
|
return {
|
|
"kind": "just",
|
|
"parameters": {
|
|
"value": value
|
|
}
|
|
};
|
|
}
|
|
lib_maybe.make_just = make_just;
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
function is_nothing(maybe) {
|
|
return (maybe.kind === "nothing");
|
|
}
|
|
lib_maybe.is_nothing = is_nothing;
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
function is_just(maybe) {
|
|
return (maybe.kind === "just");
|
|
}
|
|
lib_maybe.is_just = is_just;
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
function cull(maybe) {
|
|
if (!is_just(maybe)) {
|
|
var message = "cull from nothing";
|
|
throw (new Error(message));
|
|
}
|
|
else {
|
|
var value = maybe.parameters["value"];
|
|
return value;
|
|
}
|
|
}
|
|
lib_maybe.cull = cull;
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
function propagate(maybe, function_) {
|
|
if (!is_just(maybe)) {
|
|
}
|
|
else {
|
|
var value = maybe.parameters["value"];
|
|
var maybe_ = function_(value);
|
|
return maybe_;
|
|
}
|
|
}
|
|
lib_maybe.propagate = propagate;
|
|
})(lib_maybe || (lib_maybe = {}));
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
/*export*/ var class_maybe = /** @class */ (function () {
|
|
function class_maybe() {
|
|
}
|
|
/**
|
|
* @desc whether the wrapper is nothing
|
|
* @author fenris
|
|
*/
|
|
class_maybe.prototype.is_nothing = function () {
|
|
throw (new Error("not implemented: class_maybe.is_nothing"));
|
|
};
|
|
/**
|
|
* @desc whether the wrapper is just
|
|
* @author fenris
|
|
*/
|
|
class_maybe.prototype.is_just = function () {
|
|
throw (new Error("not implemented: class_maybe.is_just"));
|
|
};
|
|
/**
|
|
* @desc return the value, stored in the maybe-wrapper
|
|
* @author fenris
|
|
*/
|
|
class_maybe.prototype.cull = function () {
|
|
throw (new Error("not implemented: class_maybe.cull"));
|
|
};
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
class_maybe.prototype.toString = function () {
|
|
throw (new Error("not implemented: class_maybe.cull"));
|
|
};
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
class_maybe.prototype.distinguish = function (action_just, action_nothing) {
|
|
if (action_nothing === void 0) { action_nothing = function () { }; }
|
|
throw (new Error("not implemented: class_maybe.distinguish"));
|
|
};
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
class_maybe.prototype.propagate = function (action) {
|
|
throw (new Error("not implemented: class_maybe.propagate"));
|
|
};
|
|
/**
|
|
* @desc [implementation]
|
|
* @author fenris
|
|
*/
|
|
class_maybe.prototype._show = function () {
|
|
return this.toString();
|
|
};
|
|
return class_maybe;
|
|
}());
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
/*export*/ var class_nothing = /** @class */ (function (_super) {
|
|
__extends(class_nothing, _super);
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
function class_nothing(reason) {
|
|
if (reason === void 0) { reason = null; }
|
|
var _this = _super.call(this) || this;
|
|
_this.reason = reason;
|
|
return _this;
|
|
}
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
class_nothing.prototype.is_nothing = function () {
|
|
return true;
|
|
};
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
class_nothing.prototype.is_just = function () {
|
|
return false;
|
|
};
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
class_nothing.prototype.cull = function () {
|
|
var message = "you shouldn't cull a nothing-value …";
|
|
lib_log.warn(message);
|
|
return null;
|
|
};
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
class_nothing.prototype.toString = function () {
|
|
return "<\u00B7>";
|
|
};
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
class_nothing.prototype.reason_get = function () {
|
|
var content = ((this.reason == null) ? "·" : this.reason);
|
|
return "<- " + content + " ->";
|
|
};
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
class_nothing.prototype.distinguish = function (action_just, action_nothing) {
|
|
if (action_nothing === void 0) { action_nothing = function () { }; }
|
|
action_nothing(this.reason);
|
|
};
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
class_nothing.prototype.propagate = function (action) {
|
|
return (new class_nothing(this.reason));
|
|
};
|
|
return class_nothing;
|
|
}(class_maybe));
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
/*export*/ var class_just = /** @class */ (function (_super) {
|
|
__extends(class_just, _super);
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
function class_just(value) {
|
|
var _this = _super.call(this) || this;
|
|
_this.value = value;
|
|
return _this;
|
|
}
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
class_just.prototype.is_nothing = function () {
|
|
return false;
|
|
};
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
class_just.prototype.is_just = function () {
|
|
return true;
|
|
};
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
class_just.prototype.cull = function () {
|
|
return this.value;
|
|
};
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
class_just.prototype.toString = function () {
|
|
var content = instance_show(this.value);
|
|
return "<+ " + content + " +>";
|
|
};
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
class_just.prototype.distinguish = function (action_just, action_nothing) {
|
|
if (action_nothing === void 0) { action_nothing = function () { }; }
|
|
action_just(this.value);
|
|
};
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
class_just.prototype.propagate = function (action) {
|
|
return action(this.value);
|
|
};
|
|
return class_just;
|
|
}(class_maybe));
|
|
/*
|
|
This file is part of »bacterio-plankton:base«.
|
|
|
|
Copyright 2016-2021 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
|
|
<info@greenscale.de>
|
|
|
|
»bacterio-plankton:base« is free software: you can redistribute it and/or modify
|
|
it under the terms of the GNU Lesser General Public License as published by
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
»bacterio-plankton:base« is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU Lesser General Public License for more details.
|
|
|
|
You should have received a copy of the GNU Lesser General Public License
|
|
along with »bacterio-plankton:base«. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
/**
|
|
* @author frac
|
|
*/
|
|
var class_error = /** @class */ (function (_super) {
|
|
__extends(class_error, _super);
|
|
/**
|
|
* @author frac
|
|
*/
|
|
function class_error(message, suberrors) {
|
|
if (suberrors === void 0) { suberrors = []; }
|
|
var _this = _super.call(this, message) || this;
|
|
_this.suberrors = suberrors;
|
|
_this.mess = message;
|
|
return _this;
|
|
}
|
|
/**
|
|
* @override
|
|
* @author frac
|
|
*/
|
|
class_error.prototype.toString = function () {
|
|
return ( /*super.toString()*/this.mess + " " + ("[" + this.suberrors.map(function (x) { return x.toString(); }).join(",") + "]"));
|
|
};
|
|
return class_error;
|
|
}(Error));
|
|
var __extends = (this && this.__extends) || (function () {
|
|
var extendStatics = function (d, b) {
|
|
extendStatics = Object.setPrototypeOf ||
|
|
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
|
|
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
|
|
return extendStatics(d, b);
|
|
};
|
|
return function (d, b) {
|
|
extendStatics(d, b);
|
|
function __() { this.constructor = d; }
|
|
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
|
|
};
|
|
})();
|
|
/*
|
|
This file is part of »bacterio-plankton:log«.
|
|
|
|
Copyright 2016-2021 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
|
|
<info@greenscale.de>
|
|
|
|
»bacterio-plankton:log« is free software: you can redistribute it and/or modify
|
|
it under the terms of the GNU Lesser General Public License as published by
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
»bacterio-plankton:lang« is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU Lesser General Public License for more details.
|
|
|
|
You should have received a copy of the GNU Lesser General Public License
|
|
along with »bacterio-plankton:lang«. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
var lib_plankton;
|
|
(function (lib_plankton) {
|
|
var log;
|
|
(function (log) {
|
|
/**
|
|
*/
|
|
var enum_level;
|
|
(function (enum_level) {
|
|
enum_level[enum_level["debug"] = 0] = "debug";
|
|
enum_level[enum_level["info"] = 1] = "info";
|
|
enum_level[enum_level["notice"] = 2] = "notice";
|
|
enum_level[enum_level["warning"] = 3] = "warning";
|
|
enum_level[enum_level["error"] = 4] = "error";
|
|
})(enum_level = log.enum_level || (log.enum_level = {}));
|
|
;
|
|
/**
|
|
*/
|
|
function level_order(level1, level2) {
|
|
return (level1 <= level2);
|
|
}
|
|
log.level_order = level_order;
|
|
/**
|
|
*/
|
|
function level_show(level) {
|
|
switch (level) {
|
|
case enum_level.debug: return "debug";
|
|
case enum_level.info: return "info";
|
|
case enum_level.notice: return "notice";
|
|
case enum_level.warning: return "warning";
|
|
case enum_level.error: return "error";
|
|
default: return "(unknown)";
|
|
}
|
|
}
|
|
log.level_show = level_show;
|
|
})(log = lib_plankton.log || (lib_plankton.log = {}));
|
|
})(lib_plankton || (lib_plankton = {}));
|
|
/*
|
|
This file is part of »bacterio-plankton:log«.
|
|
|
|
Copyright 2016-2021 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
|
|
<info@greenscale.de>
|
|
|
|
»bacterio-plankton:log« is free software: you can redistribute it and/or modify
|
|
it under the terms of the GNU Lesser General Public License as published by
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
»bacterio-plankton:lang« is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU Lesser General Public License for more details.
|
|
|
|
You should have received a copy of the GNU Lesser General Public License
|
|
along with »bacterio-plankton:lang«. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
/**
|
|
* @deprecated
|
|
* @todo remove
|
|
*/
|
|
var lib_log;
|
|
(function (lib_log) {
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
/*export*/ var level_stack = [0];
|
|
function level_push(level) { level_stack.push(level); }
|
|
lib_log.level_push = level_push;
|
|
function level_pop() { if (level_stack.length > 1) {
|
|
level_stack.pop();
|
|
} }
|
|
lib_log.level_pop = level_pop;
|
|
function level_get() { return level_stack.slice(-1)[0]; }
|
|
/*
|
|
export function level_inc() : void {level_push(level_get()+1);}
|
|
export function level_dec() : void {level_push(level_get()-1);}
|
|
*/
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
var indent_stack = [0];
|
|
function indent_push(indent) { indent_stack.push(indent); }
|
|
lib_log.indent_push = indent_push;
|
|
function indent_pop() { if (indent_stack.length > 1) {
|
|
indent_stack.pop();
|
|
} }
|
|
lib_log.indent_pop = indent_pop;
|
|
function indent_get() { return level_stack.slice(-1)[0]; }
|
|
function indent_inc() { level_push(level_get() + 1); }
|
|
lib_log.indent_inc = indent_inc;
|
|
function indent_dec() { level_push(level_get() - 1); }
|
|
lib_log.indent_dec = indent_dec;
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
function write(_a) {
|
|
var message = _a["message"], _b = _a["type"], type = _b === void 0 ? null : _b, _c = _a["prefix"], prefix = _c === void 0 ? null : _c, _d = _a["level"], level = _d === void 0 ? 0 : _d, _e = _a["indent"], indent = _e === void 0 ? 0 : _e;
|
|
var entry = {
|
|
"level": ((type === null)
|
|
? lib_plankton.log.enum_level.info
|
|
: {
|
|
"debug": lib_plankton.log.enum_level.debug,
|
|
"info": lib_plankton.log.enum_level.info,
|
|
"notice": lib_plankton.log.enum_level.notice,
|
|
"warning": lib_plankton.log.enum_level.warning,
|
|
"error": lib_plankton.log.enum_level.error
|
|
}[type]),
|
|
"incident": message,
|
|
"details": {
|
|
"prefix": prefix,
|
|
"level": level,
|
|
"indent": indent
|
|
}
|
|
};
|
|
lib_plankton.log.add(entry);
|
|
}
|
|
lib_log.write = write;
|
|
})(lib_log || (lib_log = {}));
|
|
/*
|
|
This file is part of »bacterio-plankton:log«.
|
|
|
|
Copyright 2016-2021 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
|
|
<info@greenscale.de>
|
|
|
|
»bacterio-plankton:log« is free software: you can redistribute it and/or modify
|
|
it under the terms of the GNU Lesser General Public License as published by
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
»bacterio-plankton:lang« is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU Lesser General Public License for more details.
|
|
|
|
You should have received a copy of the GNU Lesser General Public License
|
|
along with »bacterio-plankton:lang«. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
var lib_plankton;
|
|
(function (lib_plankton) {
|
|
var log;
|
|
(function (log) {
|
|
/**
|
|
*/
|
|
var class_channel = /** @class */ (function () {
|
|
function class_channel() {
|
|
}
|
|
return class_channel;
|
|
}());
|
|
log.class_channel = class_channel;
|
|
})(log = lib_plankton.log || (lib_plankton.log = {}));
|
|
})(lib_plankton || (lib_plankton = {}));
|
|
/*
|
|
This file is part of »bacterio-plankton:log«.
|
|
|
|
Copyright 2016-2021 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
|
|
<info@greenscale.de>
|
|
|
|
»bacterio-plankton:log« is free software: you can redistribute it and/or modify
|
|
it under the terms of the GNU Lesser General Public License as published by
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
»bacterio-plankton:lang« is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU Lesser General Public License for more details.
|
|
|
|
You should have received a copy of the GNU Lesser General Public License
|
|
along with »bacterio-plankton:lang«. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
var lib_plankton;
|
|
(function (lib_plankton) {
|
|
var log;
|
|
(function (log) {
|
|
/**
|
|
*/
|
|
var class_channel_console = /** @class */ (function (_super) {
|
|
__extends(class_channel_console, _super);
|
|
function class_channel_console() {
|
|
return _super !== null && _super.apply(this, arguments) || this;
|
|
}
|
|
/**
|
|
*/
|
|
class_channel_console.prototype.add = function (entry) {
|
|
console.log(("<" + (new Date(Date.now())).toISOString().slice(0, 19) + ">")
|
|
+
|
|
" "
|
|
+
|
|
("[" + log.level_show(entry.level) + "]")
|
|
+
|
|
" "
|
|
+
|
|
("" + entry.incident + "")
|
|
+
|
|
": "
|
|
+
|
|
JSON.stringify(entry.details, undefined, " "));
|
|
};
|
|
return class_channel_console;
|
|
}(log.class_channel));
|
|
log.class_channel_console = class_channel_console;
|
|
})(log = lib_plankton.log || (lib_plankton.log = {}));
|
|
})(lib_plankton || (lib_plankton = {}));
|
|
/*
|
|
This file is part of »bacterio-plankton:log«.
|
|
|
|
Copyright 2016-2021 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
|
|
<info@greenscale.de>
|
|
|
|
»bacterio-plankton:log« is free software: you can redistribute it and/or modify
|
|
it under the terms of the GNU Lesser General Public License as published by
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
»bacterio-plankton:lang« is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU Lesser General Public License for more details.
|
|
|
|
You should have received a copy of the GNU Lesser General Public License
|
|
along with »bacterio-plankton:lang«. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
var lib_plankton;
|
|
(function (lib_plankton) {
|
|
var log;
|
|
(function (log) {
|
|
/**
|
|
*/
|
|
var class_channel_notify = /** @class */ (function (_super) {
|
|
__extends(class_channel_notify, _super);
|
|
function class_channel_notify() {
|
|
return _super !== null && _super.apply(this, arguments) || this;
|
|
}
|
|
/**
|
|
*/
|
|
class_channel_notify.prototype.add = function (entry) {
|
|
var nm_child_process = require("child_process");
|
|
var command = ("notify-send"
|
|
+
|
|
" "
|
|
+
|
|
("'"
|
|
+
|
|
("[" + log.level_show(entry.level) + "]")
|
|
+
|
|
" "
|
|
+
|
|
entry.incident
|
|
+
|
|
"'")
|
|
+
|
|
" "
|
|
+
|
|
("'"
|
|
+
|
|
(Object.keys(entry.details)
|
|
.map(function (key) { return (key + ": " + JSON.stringify(entry.details[key])); })
|
|
.join("\n"))
|
|
+
|
|
"'"));
|
|
nm_child_process.exec(command, function (error, stdout, stderr) {
|
|
// do noting
|
|
});
|
|
};
|
|
return class_channel_notify;
|
|
}(log.class_channel));
|
|
log.class_channel_notify = class_channel_notify;
|
|
})(log = lib_plankton.log || (lib_plankton.log = {}));
|
|
})(lib_plankton || (lib_plankton = {}));
|
|
/*
|
|
This file is part of »bacterio-plankton:log«.
|
|
|
|
Copyright 2016-2021 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
|
|
<info@greenscale.de>
|
|
|
|
»bacterio-plankton:log« is free software: you can redistribute it and/or modify
|
|
it under the terms of the GNU Lesser General Public License as published by
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
»bacterio-plankton:lang« is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU Lesser General Public License for more details.
|
|
|
|
You should have received a copy of the GNU Lesser General Public License
|
|
along with »bacterio-plankton:lang«. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
var lib_plankton;
|
|
(function (lib_plankton) {
|
|
var log;
|
|
(function (log) {
|
|
/**
|
|
*/
|
|
var class_channel_minlevel = /** @class */ (function (_super) {
|
|
__extends(class_channel_minlevel, _super);
|
|
/**
|
|
*/
|
|
function class_channel_minlevel(core, threshold) {
|
|
var _this = _super.call(this) || this;
|
|
_this.core = core;
|
|
_this.threshold = threshold;
|
|
return _this;
|
|
}
|
|
/**
|
|
*/
|
|
class_channel_minlevel.prototype.add = function (entry) {
|
|
if (log.level_order(this.threshold, entry.level)) {
|
|
this.core.add(entry);
|
|
}
|
|
};
|
|
return class_channel_minlevel;
|
|
}(log.class_channel));
|
|
log.class_channel_minlevel = class_channel_minlevel;
|
|
})(log = lib_plankton.log || (lib_plankton.log = {}));
|
|
})(lib_plankton || (lib_plankton = {}));
|
|
/*
|
|
This file is part of »bacterio-plankton:log«.
|
|
|
|
Copyright 2016-2021 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
|
|
<info@greenscale.de>
|
|
|
|
»bacterio-plankton:log« is free software: you can redistribute it and/or modify
|
|
it under the terms of the GNU Lesser General Public License as published by
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
»bacterio-plankton:lang« is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU Lesser General Public License for more details.
|
|
|
|
You should have received a copy of the GNU Lesser General Public License
|
|
along with »bacterio-plankton:lang«. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
var lib_plankton;
|
|
(function (lib_plankton) {
|
|
var log;
|
|
(function (log) {
|
|
/**
|
|
*/
|
|
function translate_level(level_string) {
|
|
return {
|
|
"debug": log.enum_level.debug,
|
|
"info": log.enum_level.info,
|
|
"notice": log.enum_level.notice,
|
|
"warning": log.enum_level.warning,
|
|
"error": log.enum_level.error
|
|
}[level_string];
|
|
}
|
|
/**
|
|
*/
|
|
function channel_make(description) {
|
|
var _a, _b;
|
|
switch (description.kind) {
|
|
default: {
|
|
throw (new Error("unhandled log channel kind: " + description.kind));
|
|
break;
|
|
}
|
|
case "console": {
|
|
return (new log.class_channel_minlevel(new log.class_channel_console(), translate_level((_a = description.data["threshold"]) !== null && _a !== void 0 ? _a : "debug")));
|
|
break;
|
|
}
|
|
case "notify": {
|
|
return (new log.class_channel_minlevel(new log.class_channel_notify(), translate_level((_b = description.data["threshold"]) !== null && _b !== void 0 ? _b : "debug")));
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
log.channel_make = channel_make;
|
|
})(log = lib_plankton.log || (lib_plankton.log = {}));
|
|
})(lib_plankton || (lib_plankton = {}));
|
|
/*
|
|
This file is part of »bacterio-plankton:log«.
|
|
|
|
Copyright 2016-2021 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
|
|
<info@greenscale.de>
|
|
|
|
»bacterio-plankton:log« is free software: you can redistribute it and/or modify
|
|
it under the terms of the GNU Lesser General Public License as published by
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
»bacterio-plankton:lang« is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU Lesser General Public License for more details.
|
|
|
|
You should have received a copy of the GNU Lesser General Public License
|
|
along with »bacterio-plankton:lang«. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
var lib_plankton;
|
|
(function (lib_plankton) {
|
|
var log;
|
|
(function (log) {
|
|
/**
|
|
*/
|
|
var _channel_stack = null;
|
|
/**
|
|
*/
|
|
function conf_default() {
|
|
return [
|
|
new log.class_channel_minlevel(new log.class_channel_console(), log.enum_level.notice),
|
|
new log.class_channel_minlevel(new log.class_channel_notify(), log.enum_level.error),
|
|
];
|
|
}
|
|
log.conf_default = conf_default;
|
|
/**
|
|
*/
|
|
function conf_push(channels) {
|
|
if (_channel_stack === null) {
|
|
_channel_stack = [];
|
|
}
|
|
_channel_stack.push(channels);
|
|
}
|
|
log.conf_push = conf_push;
|
|
/**
|
|
*/
|
|
function conf_pop() {
|
|
if (_channel_stack.length > 0) {
|
|
_channel_stack.pop();
|
|
}
|
|
else {
|
|
// do nothing
|
|
}
|
|
}
|
|
log.conf_pop = conf_pop;
|
|
/**
|
|
*/
|
|
function setup() {
|
|
if (_channel_stack === null) {
|
|
_channel_stack = [];
|
|
conf_push(conf_default());
|
|
}
|
|
else {
|
|
// do nothing
|
|
}
|
|
}
|
|
log.setup = setup;
|
|
/**
|
|
*/
|
|
function add(entry) {
|
|
setup();
|
|
_channel_stack.slice(-1)[0].forEach(function (channel) { return channel.add(entry); });
|
|
}
|
|
log.add = add;
|
|
/**
|
|
*/
|
|
function debug(incident, details) {
|
|
if (details === void 0) { details = {}; }
|
|
add({ "level": log.enum_level.debug, "incident": incident, "details": details });
|
|
}
|
|
log.debug = debug;
|
|
/**
|
|
*/
|
|
function info(incident, details) {
|
|
if (details === void 0) { details = {}; }
|
|
add({ "level": log.enum_level.info, "incident": incident, "details": details });
|
|
}
|
|
log.info = info;
|
|
/**
|
|
*/
|
|
function notice(incident, details) {
|
|
if (details === void 0) { details = {}; }
|
|
add({ "level": log.enum_level.notice, "incident": incident, "details": details });
|
|
}
|
|
log.notice = notice;
|
|
/**
|
|
*/
|
|
function warning(incident, details) {
|
|
if (details === void 0) { details = {}; }
|
|
add({ "level": log.enum_level.warning, "incident": incident, "details": details });
|
|
}
|
|
log.warning = warning;
|
|
/**
|
|
*/
|
|
function error(incident, details) {
|
|
if (details === void 0) { details = {}; }
|
|
add({ "level": log.enum_level.error, "incident": incident, "details": details });
|
|
}
|
|
log.error = error;
|
|
})(log = lib_plankton.log || (lib_plankton.log = {}));
|
|
})(lib_plankton || (lib_plankton = {}));
|
|
/*
|
|
This file is part of »bacterio-plankton:args«.
|
|
|
|
Copyright 2016-2021 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
|
|
<info@greenscale.de>
|
|
|
|
»bacterio-plankton:args« is free software: you can redistribute it and/or modify
|
|
it under the terms of the GNU Lesser General Public License as published by
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
»bacterio-plankton:args« is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU Lesser General Public License for more details.
|
|
|
|
You should have received a copy of the GNU Lesser General Public License
|
|
along with »bacterio-plankton:args«. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
var lib_args;
|
|
(function (lib_args) {
|
|
/**
|
|
*/
|
|
var enum_environment;
|
|
(function (enum_environment) {
|
|
enum_environment["cli"] = "cli";
|
|
enum_environment["url"] = "url";
|
|
})(enum_environment = lib_args.enum_environment || (lib_args.enum_environment = {}));
|
|
;
|
|
/**
|
|
*/
|
|
var enum_kind;
|
|
(function (enum_kind) {
|
|
enum_kind["positional"] = "positional";
|
|
enum_kind["volatile"] = "volatile";
|
|
})(enum_kind = lib_args.enum_kind || (lib_args.enum_kind = {}));
|
|
;
|
|
/**
|
|
*/
|
|
var enum_type;
|
|
(function (enum_type) {
|
|
enum_type["boolean"] = "boolean";
|
|
enum_type["integer"] = "int";
|
|
enum_type["float"] = "float";
|
|
enum_type["string"] = "string";
|
|
})(enum_type = lib_args.enum_type || (lib_args.enum_type = {}));
|
|
;
|
|
/**
|
|
*/
|
|
var enum_mode;
|
|
(function (enum_mode) {
|
|
enum_mode["replace"] = "replace";
|
|
enum_mode["accumulate"] = "accumulate";
|
|
})(enum_mode = lib_args.enum_mode || (lib_args.enum_mode = {}));
|
|
;
|
|
})(lib_args || (lib_args = {}));
|
|
/*
|
|
This file is part of »bacterio-plankton:args«.
|
|
|
|
Copyright 2016-2021 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
|
|
<info@greenscale.de>
|
|
|
|
»bacterio-plankton:args« is free software: you can redistribute it and/or modify
|
|
it under the terms of the GNU Lesser General Public License as published by
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
»bacterio-plankton:args« is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU Lesser General Public License for more details.
|
|
|
|
You should have received a copy of the GNU Lesser General Public License
|
|
along with »bacterio-plankton:args«. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
var lib_args;
|
|
(function (lib_args) {
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
var class_argument = /** @class */ (function () {
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
function class_argument(_a) {
|
|
var name = _a["name"], _b = _a["type"], type = _b === void 0 ? lib_args.enum_type.string : _b, _c = _a["kind"], kind = _c === void 0 ? lib_args.enum_kind.positional : _c, _d = _a["mode"], mode = _d === void 0 ? lib_args.enum_mode.replace : _d, _e = _a["default"], default_ = _e === void 0 ? null : _e, _f = _a["info"], info = _f === void 0 ? null : _f, _g = _a["parameters"], parameters = _g === void 0 ? {} : _g, _h = _a["hidden"], hidden = _h === void 0 ? false : _h;
|
|
this.name = name;
|
|
this.type = type;
|
|
this.kind = kind;
|
|
this.mode = mode;
|
|
this.default_ = default_;
|
|
this.info = info;
|
|
this.parameters = parameters;
|
|
this.hidden = hidden;
|
|
if (!this.check()) {
|
|
throw (new Error("invalid argument-setup"));
|
|
}
|
|
}
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
class_argument.positional = function (_a) {
|
|
var name = _a["name"], _b = _a["type"], type = _b === void 0 ? lib_args.enum_type.string : _b, _c = _a["mode"], mode = _c === void 0 ? lib_args.enum_mode.replace : _c, _d = _a["default"], default_ = _d === void 0 ? null : _d, _e = _a["info"], info = _e === void 0 ? null : _e, _f = _a["hidden"], hidden = _f === void 0 ? false : _f, index = _a["index"];
|
|
return (new class_argument({
|
|
"name": name,
|
|
"kind": lib_args.enum_kind.positional,
|
|
"type": type,
|
|
"mode": mode,
|
|
"default": default_,
|
|
"info": info,
|
|
"hidden": hidden,
|
|
"parameters": {
|
|
"index": index
|
|
}
|
|
}));
|
|
};
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
class_argument.volatile = function (_a) {
|
|
var name = _a["name"], _b = _a["type"], type = _b === void 0 ? lib_args.enum_type.string : _b, _c = _a["mode"], mode = _c === void 0 ? lib_args.enum_mode.replace : _c, _d = _a["default"], default_ = _d === void 0 ? null : _d, _e = _a["info"], info = _e === void 0 ? null : _e, _f = _a["hidden"], hidden = _f === void 0 ? false : _f, indicators_short = _a["indicators_short"], indicators_long = _a["indicators_long"];
|
|
return (new class_argument({
|
|
"name": name,
|
|
"kind": lib_args.enum_kind.volatile,
|
|
"type": type,
|
|
"mode": mode,
|
|
"default": default_,
|
|
"info": info,
|
|
"hidden": hidden,
|
|
"parameters": {
|
|
"indicators_short": indicators_short,
|
|
"indicators_long": indicators_long
|
|
}
|
|
}));
|
|
};
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
class_argument.prototype.check = function () {
|
|
var _this = this;
|
|
return [
|
|
function () { return ((!(_this.kind == lib_args.enum_kind.volatile))
|
|
||
|
|
(("indicators_long" in _this.parameters)
|
|
&&
|
|
(_this.parameters["indicators_long"]["length"] >= 0))); },
|
|
].every(function (condition) { return condition(); });
|
|
};
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
class_argument.prototype.name_get = function () {
|
|
return this.name;
|
|
};
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
class_argument.prototype.kind_get = function () {
|
|
return this.kind;
|
|
};
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
class_argument.prototype.type_get = function () {
|
|
return this.type;
|
|
};
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
class_argument.prototype.mode_get = function () {
|
|
return this.mode;
|
|
};
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
class_argument.prototype.default_get = function () {
|
|
return this.default_;
|
|
};
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
class_argument.prototype.parameters_get = function () {
|
|
return this.parameters;
|
|
};
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
class_argument.prototype.hidden_get = function () {
|
|
return this.hidden;
|
|
};
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
class_argument.prototype.toString = function () {
|
|
return "<" + this.name + ">";
|
|
};
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
class_argument.prototype.indicator_main = function () {
|
|
if (this.kind === lib_args.enum_kind.volatile) {
|
|
return this.parameters["indicators_long"][0];
|
|
}
|
|
else {
|
|
return null;
|
|
}
|
|
};
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
class_argument.prototype.pattern_value = function () {
|
|
switch (this.type) {
|
|
case lib_args.enum_type.boolean: {
|
|
return "false|true";
|
|
break;
|
|
}
|
|
case lib_args.enum_type.integer: {
|
|
return "[0-9]+";
|
|
break;
|
|
}
|
|
case lib_args.enum_type.float: {
|
|
return "\\d*(?:\\.\\d+)?";
|
|
break;
|
|
}
|
|
case lib_args.enum_type.string: {
|
|
return "\\S+";
|
|
break;
|
|
}
|
|
default: {
|
|
throw (new Error("unhandled type " + this.type));
|
|
break;
|
|
}
|
|
}
|
|
};
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
class_argument.prototype.extract = function (raw) {
|
|
switch (this.type) {
|
|
case lib_args.enum_type.boolean: {
|
|
return (raw != "false");
|
|
break;
|
|
}
|
|
case lib_args.enum_type.integer: {
|
|
return parseInt(raw);
|
|
break;
|
|
}
|
|
case lib_args.enum_type.float: {
|
|
return parseFloat(raw);
|
|
break;
|
|
}
|
|
case lib_args.enum_type.string: {
|
|
return raw;
|
|
break;
|
|
}
|
|
default: {
|
|
throw (new Error("unhandled type " + this.type));
|
|
break;
|
|
}
|
|
}
|
|
};
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
class_argument.prototype.assign = function (data, target, raw) {
|
|
var value = this.extract(raw);
|
|
switch (this.mode) {
|
|
case lib_args.enum_mode.replace: {
|
|
data[target] = value;
|
|
break;
|
|
}
|
|
case lib_args.enum_mode.accumulate: {
|
|
/*
|
|
if (! (this.name in data)) {
|
|
data[this.name] = [];
|
|
}
|
|
*/
|
|
data[target].push(value);
|
|
break;
|
|
}
|
|
default: {
|
|
throw (new Error("unhandled mode " + this.mode));
|
|
}
|
|
}
|
|
};
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
class_argument.prototype.make = function (data, target) {
|
|
var value = data[target];
|
|
return value.toString();
|
|
};
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
class_argument.prototype.generate_help = function () {
|
|
var _this = this;
|
|
var _a, _b, _c, _d;
|
|
var output = "";
|
|
{
|
|
switch (this.kind) {
|
|
case lib_args.enum_kind.positional: {
|
|
var line = "";
|
|
line += "\t";
|
|
line += "<" + this.name + ">";
|
|
line += "\n";
|
|
output += line;
|
|
}
|
|
case lib_args.enum_kind.volatile: {
|
|
var line = "";
|
|
line += "\t";
|
|
if (this.type === lib_args.enum_type.boolean) {
|
|
line += ([]
|
|
.concat(((_a = this.parameters["indicators_short"]) !== null && _a !== void 0 ? _a : []).map(function (indicator) { return ("-" + indicator); }))
|
|
.concat(((_b = this.parameters["indicators_long"]) !== null && _b !== void 0 ? _b : []).map(function (indicator) { return ("--" + indicator); }))
|
|
.join(" | "));
|
|
}
|
|
else {
|
|
line += ([]
|
|
.concat(((_c = this.parameters["indicators_short"]) !== null && _c !== void 0 ? _c : []).map(function (indicator) { return ("-" + indicator + " " + ("<" + _this.name + ">")); }))
|
|
.concat(((_d = this.parameters["indicators_long"]) !== null && _d !== void 0 ? _d : []).map(function (indicator) { return ("--" + indicator + "=" + ("<" + _this.name + ">")); }))
|
|
.join(" | "));
|
|
}
|
|
line += "\n";
|
|
output += line;
|
|
}
|
|
}
|
|
}
|
|
{
|
|
var line = "";
|
|
line += "\t\t";
|
|
var infotext = ((this.info == null) ? "(no info available)" : this.info);
|
|
line += infotext;
|
|
if ((this.type != "boolean") && (this.default_ != null)) {
|
|
line += "; default: " + this.default_.toString();
|
|
}
|
|
line += "\n";
|
|
output += line;
|
|
}
|
|
return output;
|
|
};
|
|
return class_argument;
|
|
}());
|
|
lib_args.class_argument = class_argument;
|
|
})(lib_args || (lib_args = {}));
|
|
/*
|
|
This file is part of »bacterio-plankton:args«.
|
|
|
|
Copyright 2016-2021 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
|
|
<info@greenscale.de>
|
|
|
|
»bacterio-plankton:args« is free software: you can redistribute it and/or modify
|
|
it under the terms of the GNU Lesser General Public License as published by
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
»bacterio-plankton:args« is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU Lesser General Public License for more details.
|
|
|
|
You should have received a copy of the GNU Lesser General Public License
|
|
along with »bacterio-plankton:args«. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
var lib_args;
|
|
(function (lib_args) {
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
var settings = {
|
|
"environment": {
|
|
"cli": {
|
|
"symbols": {
|
|
"delimiter": " ",
|
|
"prefix": "--",
|
|
"assignment": "="
|
|
}
|
|
},
|
|
"url": {
|
|
"symbols": {
|
|
"delimiter": "&",
|
|
"prefix": "",
|
|
"assignment": "="
|
|
}
|
|
}
|
|
}
|
|
};
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
lib_args.verbosity = 0;
|
|
/**
|
|
* @author fenris
|
|
* @todo check validity
|
|
*/
|
|
var class_handler = /** @class */ (function () {
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
function class_handler(arguments_) {
|
|
this.arguments_ = arguments_;
|
|
}
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
class_handler.prototype.filter = function (kind) {
|
|
var arguments_ = {};
|
|
for (var _i = 0, _a = Object.entries(this.arguments_); _i < _a.length; _i++) {
|
|
var _b = _a[_i], name = _b[0], argument = _b[1];
|
|
if (argument.kind_get() == kind) {
|
|
arguments_[name] = argument;
|
|
}
|
|
}
|
|
return arguments_;
|
|
};
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
class_handler.prototype.read = function (environment, input, data) {
|
|
var _this = this;
|
|
if (data === void 0) { data = {}; }
|
|
switch (environment) {
|
|
case lib_args.enum_environment.cli:
|
|
case lib_args.enum_environment.url: {
|
|
// default values
|
|
{
|
|
for (var _i = 0, _a = Object.entries(this.arguments_); _i < _a.length; _i++) {
|
|
var _b = _a[_i], name = _b[0], argument = _b[1];
|
|
data[name] = argument.default_get();
|
|
}
|
|
}
|
|
// preprocessing
|
|
{
|
|
// short indicators (lil hacky ...)
|
|
{
|
|
if (environment == lib_args.enum_environment.cli) {
|
|
for (var _c = 0, _d = Object.entries(this.filter(lib_args.enum_kind.volatile)); _c < _d.length; _c++) {
|
|
var _e = _d[_c], name = _e[0], argument = _e[1];
|
|
// console.info(argument.parameters_get()["indicators_short"].join("|"));
|
|
var pattern_from = "";
|
|
{
|
|
pattern_from += "(?:^|" + settings["environment"][environment]["symbols"]["delimiter"] + ")";
|
|
pattern_from += "-" + argument.parameters_get()["indicators_short"].join("|");
|
|
pattern_from += "(?:$|" + settings["environment"][environment]["symbols"]["delimiter"] + ")";
|
|
}
|
|
var pattern_to = "";
|
|
{
|
|
pattern_to += settings["environment"][environment]["symbols"]["delimiter"];
|
|
pattern_to += settings["environment"][environment]["symbols"]["prefix"];
|
|
pattern_to += argument.indicator_main();
|
|
if (argument.type_get() == lib_args.enum_type.boolean) {
|
|
pattern_to += settings["environment"][environment]["symbols"]["delimiter"];
|
|
}
|
|
else {
|
|
pattern_to += settings["environment"][environment]["symbols"]["assignment"];
|
|
}
|
|
}
|
|
var result = input.replace(new RegExp(pattern_from, "g"), pattern_to);
|
|
lib_plankton.log.debug("lib_args:read:replacing", {
|
|
"pattern_from": pattern_from,
|
|
"pattern_to": pattern_to,
|
|
"input": input,
|
|
"result": result
|
|
});
|
|
input = result;
|
|
}
|
|
}
|
|
}
|
|
lib_plankton.log.debug("lib_args:read:current_input", {
|
|
"input": input
|
|
});
|
|
}
|
|
// parsing
|
|
{
|
|
var parts = input
|
|
.split(settings["environment"][environment]["symbols"]["delimiter"])
|
|
.filter(function (x) { return (x != ""); });
|
|
var index_expected_1 = 0;
|
|
parts.forEach(function (part) {
|
|
lib_plankton.log.debug("lib_args:read:analyzing", {
|
|
"part": part
|
|
});
|
|
var found = [
|
|
function () {
|
|
lib_plankton.log.debug("lib_args:read:probing_as_volatile", {
|
|
"part": part
|
|
});
|
|
for (var _i = 0, _a = Object.entries(_this.filter(lib_args.enum_kind.volatile)); _i < _a.length; _i++) {
|
|
var _b = _a[_i], name = _b[0], argument = _b[1];
|
|
lib_plankton.log.debug("lib_args:read:probing_as_volatile:trying", {
|
|
"part": part,
|
|
"argument": argument.toString()
|
|
});
|
|
var pattern = "";
|
|
{
|
|
var pattern_front = "";
|
|
pattern_front += "" + settings["environment"][environment]["symbols"]["prefix"];
|
|
pattern_front += "(?:" + argument.parameters_get()["indicators_long"].join("|") + ")";
|
|
pattern += pattern_front;
|
|
}
|
|
{
|
|
var pattern_back = "";
|
|
pattern_back += "" + settings["environment"][environment]["symbols"]["assignment"];
|
|
pattern_back += "(" + argument.pattern_value() + ")";
|
|
if (argument.type_get() == lib_args.enum_type.boolean) {
|
|
pattern_back = "(?:" + pattern_back + ")?";
|
|
}
|
|
pattern += pattern_back;
|
|
}
|
|
lib_plankton.log.debug("lib_args:read:probing_as_volatile:pattern", {
|
|
"pattern": pattern
|
|
});
|
|
var regexp = new RegExp(pattern);
|
|
var matching = regexp.exec(part);
|
|
lib_plankton.log.debug("lib_args:read:probing_as_volatile:matching", {
|
|
"matching": matching
|
|
});
|
|
if (matching == null) {
|
|
// do nothing
|
|
}
|
|
else {
|
|
argument.assign(data, name, matching[1]);
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
},
|
|
function () {
|
|
lib_plankton.log.debug("lib_args:read:probing_as_positional", {
|
|
"part": part
|
|
});
|
|
var positional = _this.filter(lib_args.enum_kind.positional);
|
|
for (var _i = 0, _a = Object.entries(positional); _i < _a.length; _i++) {
|
|
var _b = _a[_i], name = _b[0], argument = _b[1];
|
|
if (argument.parameters_get()['index'] !== index_expected_1) {
|
|
// do nothing
|
|
}
|
|
else {
|
|
lib_plankton.log.debug("lib_args:read:probing_as_positional:trying", {
|
|
"part": part,
|
|
"argument": argument.toString()
|
|
});
|
|
var pattern = "";
|
|
{
|
|
var pattern_back = "";
|
|
pattern_back += "(" + argument.pattern_value() + ")";
|
|
pattern += pattern_back;
|
|
}
|
|
lib_plankton.log.debug("lib_args:read:probing_as_positional:pattern", {
|
|
"pattern": pattern
|
|
});
|
|
var regexp = new RegExp(pattern);
|
|
var matching = regexp.exec(part);
|
|
lib_plankton.log.debug("lib_args:read:probing_as_positional:matching", {
|
|
"matching": matching
|
|
});
|
|
if (matching == null) {
|
|
return false;
|
|
}
|
|
else {
|
|
argument.assign(data, name, matching[1]);
|
|
index_expected_1 += 1;
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
},
|
|
].some(function (x) { return x(); });
|
|
if (!found) {
|
|
lib_plankton.log.warning("lib_args:read:could_not_parse", {
|
|
"part": part
|
|
});
|
|
}
|
|
});
|
|
}
|
|
return data;
|
|
break;
|
|
}
|
|
default: {
|
|
throw (new Error("unhandled environment " + environment));
|
|
break;
|
|
}
|
|
}
|
|
};
|
|
/**
|
|
* @author fenris
|
|
* @todo handle if the data object doesn't have the required field or the type is wrong or sth.
|
|
*/
|
|
class_handler.prototype.write = function (environment, data) {
|
|
switch (environment) {
|
|
case lib_args.enum_environment.cli: {
|
|
return (([]
|
|
.concat(Object.entries(this.filter(lib_args.enum_kind.volatile)).map(function (_a) {
|
|
var name = _a[0], argument = _a[1];
|
|
var values;
|
|
switch (argument.mode_get()) {
|
|
case lib_args.enum_mode.replace: {
|
|
values = [data[argument.name_get()]];
|
|
break;
|
|
}
|
|
case lib_args.enum_mode.accumulate: {
|
|
values = data[argument.name_get()];
|
|
break;
|
|
}
|
|
}
|
|
return (values
|
|
.map(function (value) { return ((settings["environment"][environment]["symbols"]["prefix"]
|
|
+
|
|
argument.parameters_get()["indicators_long"][0])
|
|
+
|
|
(settings["environment"][environment]["symbols"]["assignment"]
|
|
+
|
|
value.toString())); })
|
|
.join(" "));
|
|
}))
|
|
.concat(Object.entries(this.filter(lib_args.enum_kind.positional)).map(function (_a) {
|
|
var name = _a[0], argument = _a[1];
|
|
var raw = "";
|
|
{
|
|
var raw_back = "";
|
|
raw_back += argument.make(data, name);
|
|
raw += raw_back;
|
|
}
|
|
return raw;
|
|
})))
|
|
.join(settings["environment"][environment]["symbols"]["delimiter"]));
|
|
break;
|
|
}
|
|
default: {
|
|
throw (new Error("unhandled environment " + environment));
|
|
break;
|
|
}
|
|
}
|
|
};
|
|
/**
|
|
* @desc manpage-like info-sheet
|
|
* @author fenris
|
|
*/
|
|
class_handler.prototype.generate_help = function (_a) {
|
|
var _b = _a["programname"], programname = _b === void 0 ? null : _b, _c = _a["author"], author = _c === void 0 ? null : _c, _d = _a["description"], description = _d === void 0 ? null : _d, _e = _a["executable"], executable = _e === void 0 ? null : _e;
|
|
var environment = lib_args.enum_environment.cli;
|
|
var output = "";
|
|
{
|
|
var section = "";
|
|
{
|
|
var line = "";
|
|
line += "";
|
|
line += "INFO";
|
|
line += "\n";
|
|
section += line;
|
|
}
|
|
{
|
|
var line = "";
|
|
line += "\t";
|
|
line += programname + " -- " + description;
|
|
line += "\n";
|
|
section += line;
|
|
}
|
|
section += "\n";
|
|
output += section;
|
|
}
|
|
{
|
|
if (author != null) {
|
|
var section = "";
|
|
{
|
|
var line = "";
|
|
line += "";
|
|
line += "AUTHOR";
|
|
line += "\n";
|
|
section += line;
|
|
}
|
|
{
|
|
var line = "";
|
|
line += "\t";
|
|
line += "" + author;
|
|
line += "\n";
|
|
section += line;
|
|
}
|
|
section += "\n";
|
|
output += section;
|
|
}
|
|
}
|
|
{
|
|
var section = "";
|
|
{
|
|
var line = "";
|
|
line += "";
|
|
line += "SYNOPSIS";
|
|
line += "\n";
|
|
section += line;
|
|
}
|
|
{
|
|
var line = "";
|
|
line += "\t";
|
|
line += executable;
|
|
line += settings["environment"][environment]["symbols"]["delimiter"];
|
|
line += Object.entries(this.filter(lib_args.enum_kind.positional))
|
|
.map(function (_a) {
|
|
var name = _a[0], argument = _a[1];
|
|
var part = "";
|
|
part += "<" + argument.name_get() + ">";
|
|
return part;
|
|
})
|
|
.join(settings["environment"][environment]["symbols"]["delimiter"]);
|
|
line += settings["environment"][environment]["symbols"]["delimiter"];
|
|
line += Object.entries(this.filter(lib_args.enum_kind.volatile))
|
|
.filter(function (_a) {
|
|
var name = _a[0], argument = _a[1];
|
|
return (!argument.hidden_get());
|
|
})
|
|
.map(function (_a) {
|
|
var name = _a[0], argument = _a[1];
|
|
var part = "";
|
|
// part += settings["environment"][environment]["symbols"]["prefix"];
|
|
part += "-";
|
|
part += argument.parameters_get()["indicators_short"][0];
|
|
if (argument.type_get() != "boolean") {
|
|
/*
|
|
part += settings["environment"][environment]["symbols"]["assignment"];
|
|
part += `<${argument.name_get()}>`;
|
|
*/
|
|
part += " ";
|
|
part += "<" + argument.name_get() + ">";
|
|
}
|
|
part = "[" + part + "]";
|
|
return part;
|
|
})
|
|
.join(settings["environment"][environment]["symbols"]["delimiter"]);
|
|
line += "\n";
|
|
section += line;
|
|
}
|
|
section += "\n";
|
|
output += section;
|
|
}
|
|
{
|
|
var section = "";
|
|
{
|
|
var line = "";
|
|
line += "";
|
|
line += "OPTIONS";
|
|
line += "\n";
|
|
section += line;
|
|
}
|
|
{
|
|
section += (Object.entries(this.arguments_)
|
|
.filter(function (_a) {
|
|
var name = _a[0], argument = _a[1];
|
|
return (!argument.hidden_get());
|
|
})
|
|
.map(function (_a) {
|
|
var name = _a[0], argument = _a[1];
|
|
return argument.generate_help();
|
|
})
|
|
.join("\n"));
|
|
}
|
|
section += "\n";
|
|
output += section;
|
|
}
|
|
return output;
|
|
};
|
|
return class_handler;
|
|
}());
|
|
lib_args.class_handler = class_handler;
|
|
})(lib_args || (lib_args = {}));
|
|
/*
|
|
This file is part of »bacterio-plankton:file«.
|
|
|
|
Copyright 2016-2021 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
|
|
<info@greenscale.de>
|
|
|
|
»bacterio-plankton:file« is free software: you can redistribute it and/or modify
|
|
it under the terms of the GNU Lesser General Public License as published by
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
»bacterio-plankton:file« is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU Lesser General Public License for more details.
|
|
|
|
You should have received a copy of the GNU Lesser General Public License
|
|
along with »bacterio-plankton:file«. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
var lib_plankton;
|
|
(function (lib_plankton) {
|
|
var file;
|
|
(function (file) {
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
function read(path) {
|
|
var nm_fs = require("fs");
|
|
return (new Promise(function (resolve, reject) {
|
|
nm_fs.readFile(path, {
|
|
"encoding": "utf8",
|
|
"flag": "r"
|
|
}, function (error, content) {
|
|
if (error == null) {
|
|
resolve(content);
|
|
}
|
|
else {
|
|
reject(error);
|
|
}
|
|
});
|
|
}));
|
|
}
|
|
file.read = read;
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
function read_stdin() {
|
|
return (new Promise(function (resolve, reject) {
|
|
var input_raw = "";
|
|
process.stdin.setEncoding("utf8");
|
|
process.stdin.on("readable", function () {
|
|
var chunk;
|
|
while ((chunk = process.stdin.read()) !== null) {
|
|
input_raw += chunk;
|
|
}
|
|
});
|
|
process.stdin.on("end", function () {
|
|
resolve(input_raw);
|
|
});
|
|
}));
|
|
}
|
|
file.read_stdin = read_stdin;
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
function write(path, content) {
|
|
var nm_fs = require("fs");
|
|
return (new Promise(function (resolve, reject) {
|
|
nm_fs.writeFile(path, content, {
|
|
"encoding": "utf8",
|
|
"flag": "w"
|
|
}, function (error) {
|
|
if (error == null) {
|
|
resolve(undefined);
|
|
}
|
|
else {
|
|
reject(error);
|
|
}
|
|
});
|
|
}));
|
|
}
|
|
file.write = write;
|
|
})(file = lib_plankton.file || (lib_plankton.file = {}));
|
|
})(lib_plankton || (lib_plankton = {}));
|
|
/*
|
|
This file is part of »bacterio-plankton:observer«.
|
|
|
|
Copyright 2016-2021 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
|
|
<info@greenscale.de>
|
|
|
|
»bacterio-plankton:observer« is free software: you can redistribute it and/or modify
|
|
it under the terms of the GNU Lesser General Public License as published by
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
»bacterio-plankton:observer« is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU Lesser General Public License for more details.
|
|
|
|
You should have received a copy of the GNU Lesser General Public License
|
|
along with »bacterio-plankton:observer«. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
var lib_observer;
|
|
(function (lib_observer) {
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
function make(_a) {
|
|
var _b = _a === void 0 ? {} : _a, _c = _b["force_registration"], force_registration = _c === void 0 ? false : _c, _d = _b["no_attendants_warn_do"], no_attendants_warn_do = _d === void 0 ? false : _d, _e = _b["no_attendants_warn_action"], no_attendants_warn_action = _e === void 0 ? (function (eventname) { return console.warn("no attendants for event '" + eventname + "'"); }) : _e;
|
|
return {
|
|
"actions": {},
|
|
"force_registration": force_registration,
|
|
"no_attendants_warn_do": no_attendants_warn_do,
|
|
"no_attendants_warn_action": no_attendants_warn_action,
|
|
};
|
|
}
|
|
lib_observer.make = make;
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
function present(observer, eventname) {
|
|
return (observer.actions.hasOwnProperty(eventname));
|
|
}
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
function register(observer, eventname) {
|
|
if (!present(observer, eventname)) {
|
|
observer.actions[eventname] = [];
|
|
}
|
|
else {
|
|
// do nothing
|
|
// warn that it is already registered?
|
|
}
|
|
}
|
|
lib_observer.register = register;
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
function attend(observer, eventname, action) {
|
|
if (!present(observer, eventname)) {
|
|
if (observer.force_registration) {
|
|
throw (new Error("no event '" + eventname + "'"));
|
|
}
|
|
else {
|
|
register(observer, eventname);
|
|
}
|
|
}
|
|
else {
|
|
// do nothing
|
|
}
|
|
observer.actions[eventname].push(action);
|
|
}
|
|
lib_observer.attend = attend;
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
function notify(observer, eventname, data) {
|
|
if (!present(observer, eventname)) {
|
|
if (observer.force_registration) {
|
|
throw (new Error("no event '" + eventname + "'"));
|
|
}
|
|
else {
|
|
register(observer, eventname);
|
|
}
|
|
}
|
|
else {
|
|
if (observer.no_attendants_warn_do) {
|
|
if (observer.actions[eventname].length <= 0) {
|
|
observer.no_attendants_warn_action(eventname);
|
|
}
|
|
else {
|
|
// do nothing
|
|
}
|
|
}
|
|
else {
|
|
// do nothing
|
|
}
|
|
observer.actions[eventname]
|
|
.forEach(function (action) {
|
|
action(data);
|
|
});
|
|
}
|
|
}
|
|
lib_observer.notify = notify;
|
|
})(lib_observer || (lib_observer = {}));
|
|
/*
|
|
This file is part of »bacterio-plankton:lang«.
|
|
|
|
Copyright 2016-2021 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
|
|
<info@greenscale.de>
|
|
|
|
»bacterio-plankton:lang« is free software: you can redistribute it and/or modify
|
|
it under the terms of the GNU Lesser General Public License as published by
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
»bacterio-plankton:lang« is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU Lesser General Public License for more details.
|
|
|
|
You should have received a copy of the GNU Lesser General Public License
|
|
along with »bacterio-plankton:lang«. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
var lib_plankton;
|
|
(function (lib_plankton) {
|
|
var lang;
|
|
(function (lang) {
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
function sequence(length) {
|
|
return ((length > 0) ? sequence(length - 1).concat([length - 1]) : []);
|
|
}
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
function find(word, part, equality, /*= instance_collate*/ right_to_left = false) {
|
|
let result = -1;
|
|
let found = sequence(word.length - part.length + 1).some(function (position) {
|
|
let position_ = (right_to_left
|
|
? (word.length - part.length - position)
|
|
: (position));
|
|
let matches = sequence(part.length).every(index => equality(word[position_ + index], part[index]));
|
|
if (matches) {
|
|
result = position_;
|
|
return true;
|
|
}
|
|
else {
|
|
return false;
|
|
}
|
|
});
|
|
return result;
|
|
}
|
|
lang.find = find;
|
|
})(lang = lib_plankton.lang || (lib_plankton.lang = {}));
|
|
})(lib_plankton || (lib_plankton = {}));
|
|
/*
|
|
This file is part of »bacterio-plankton:lang«.
|
|
|
|
Copyright 2016-2021 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
|
|
<info@greenscale.de>
|
|
|
|
»bacterio-plankton:lang« is free software: you can redistribute it and/or modify
|
|
it under the terms of the GNU Lesser General Public License as published by
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
»bacterio-plankton:lang« is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU Lesser General Public License for more details.
|
|
|
|
You should have received a copy of the GNU Lesser General Public License
|
|
along with »bacterio-plankton:lang«. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
/*
|
|
This file is part of »bacterio-plankton:lang«.
|
|
|
|
Copyright 2016-2021 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
|
|
<info@greenscale.de>
|
|
|
|
»bacterio-plankton:lang« is free software: you can redistribute it and/or modify
|
|
it under the terms of the GNU Lesser General Public License as published by
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
»bacterio-plankton:lang« is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU Lesser General Public License for more details.
|
|
|
|
You should have received a copy of the GNU Lesser General Public License
|
|
along with »bacterio-plankton:lang«. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
var lib_plankton;
|
|
(function (lib_plankton) {
|
|
var lang;
|
|
(function (lang) {
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
class class_symbol_terminal {
|
|
/**
|
|
* @desc [constructor]
|
|
* @author fenris
|
|
*/
|
|
constructor(terminal, equality_terminal = ((x, y) => (x == y))) {
|
|
this.terminal = terminal;
|
|
this.equality_terminal = equality_terminal;
|
|
}
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
terminal_get() {
|
|
return this.terminal;
|
|
}
|
|
/**
|
|
* @override
|
|
* @author fenris
|
|
*/
|
|
equals(symbol) {
|
|
if (symbol instanceof class_symbol_terminal) {
|
|
let symbol_terminal = (symbol);
|
|
return this.equality_terminal(this.terminal, symbol_terminal.terminal);
|
|
}
|
|
else {
|
|
return false;
|
|
}
|
|
}
|
|
/**
|
|
* @override
|
|
* @author fenris
|
|
*/
|
|
toString() {
|
|
return JSON.stringify(this);
|
|
}
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
static tree_generic(terminal) {
|
|
return (new lib_plankton.lang.class_symbol_terminal(terminal));
|
|
}
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
static tree_default(terminal) {
|
|
return (new lib_plankton.lang.class_symbol_terminal(terminal));
|
|
}
|
|
}
|
|
lang.class_symbol_terminal = class_symbol_terminal;
|
|
})(lang = lib_plankton.lang || (lib_plankton.lang = {}));
|
|
})(lib_plankton || (lib_plankton = {}));
|
|
/*
|
|
This file is part of »bacterio-plankton:lang«.
|
|
|
|
Copyright 2016-2021 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
|
|
<info@greenscale.de>
|
|
|
|
»bacterio-plankton:lang« is free software: you can redistribute it and/or modify
|
|
it under the terms of the GNU Lesser General Public License as published by
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
»bacterio-plankton:lang« is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU Lesser General Public License for more details.
|
|
|
|
You should have received a copy of the GNU Lesser General Public License
|
|
along with »bacterio-plankton:lang«. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
var lib_plankton;
|
|
(function (lib_plankton) {
|
|
var lang;
|
|
(function (lang) {
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
class class_symbol_variable {
|
|
/**
|
|
* @desc [constructor]
|
|
* @author fenris
|
|
*/
|
|
constructor(variable, meaning = undefined) {
|
|
this.variable = variable;
|
|
this.meaning = meaning;
|
|
}
|
|
/**
|
|
* @desc [accessor] [getter]
|
|
* @author fenris
|
|
*/
|
|
variable_get() {
|
|
return this.variable;
|
|
}
|
|
/**
|
|
* @desc [accessor] [getter]
|
|
* @author fenris
|
|
*/
|
|
meaning_get() {
|
|
return this.meaning;
|
|
}
|
|
/**
|
|
* @override
|
|
* @author fenris
|
|
*/
|
|
equals(symbol) {
|
|
if (symbol instanceof class_symbol_variable) {
|
|
let symbol_variable = (symbol);
|
|
return (this.variable == symbol_variable.variable);
|
|
}
|
|
else {
|
|
return false;
|
|
}
|
|
}
|
|
/**
|
|
* @override
|
|
* @author fenris
|
|
*/
|
|
toString() {
|
|
return JSON.stringify(this);
|
|
}
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
static tree_generic(variable) {
|
|
return (new lib_plankton.lang.class_symbol_variable(variable));
|
|
}
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
static tree_default(variable) {
|
|
return (new lib_plankton.lang.class_symbol_variable(variable));
|
|
}
|
|
}
|
|
lang.class_symbol_variable = class_symbol_variable;
|
|
})(lang = lib_plankton.lang || (lib_plankton.lang = {}));
|
|
})(lib_plankton || (lib_plankton = {}));
|
|
/*
|
|
This file is part of »bacterio-plankton:lang«.
|
|
|
|
Copyright 2016-2021 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
|
|
<info@greenscale.de>
|
|
|
|
»bacterio-plankton:lang« is free software: you can redistribute it and/or modify
|
|
it under the terms of the GNU Lesser General Public License as published by
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
»bacterio-plankton:lang« is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU Lesser General Public License for more details.
|
|
|
|
You should have received a copy of the GNU Lesser General Public License
|
|
along with »bacterio-plankton:lang«. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
/*
|
|
This file is part of »bacterio-plankton:lang«.
|
|
|
|
Copyright 2016-2021 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
|
|
<info@greenscale.de>
|
|
|
|
»bacterio-plankton:lang« is free software: you can redistribute it and/or modify
|
|
it under the terms of the GNU Lesser General Public License as published by
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
»bacterio-plankton:lang« is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU Lesser General Public License for more details.
|
|
|
|
You should have received a copy of the GNU Lesser General Public License
|
|
along with »bacterio-plankton:lang«. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
var lib_plankton;
|
|
(function (lib_plankton) {
|
|
var lang;
|
|
(function (lang) {
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
function lexerrule_make(search, construct) {
|
|
let observer = lib_observer.make();
|
|
lib_observer.register(observer, "start");
|
|
lib_observer.register(observer, "message_sequence");
|
|
lib_observer.register(observer, "maximum_reached");
|
|
lib_observer.attend(observer, "start", ({ "rule": rule }) => {
|
|
lib_plankton.log.debug("lang:lexer:run:current_rule", {
|
|
"rule": lexerrule_show(rule),
|
|
});
|
|
});
|
|
lib_observer.attend(observer, "message_sequence", ({ "tokens": tokens }) => {
|
|
lib_plankton.log.debug("lang:lexer:run:current_sequence", {
|
|
"tokens": tokens,
|
|
});
|
|
});
|
|
lib_observer.attend(observer, "maximum_reached", () => {
|
|
lib_plankton.log.warning("lang:lexer:run:maximum_reached", {});
|
|
});
|
|
return {
|
|
"search": search,
|
|
"construct": construct,
|
|
"observer": observer,
|
|
};
|
|
}
|
|
lang.lexerrule_make = lexerrule_make;
|
|
/**
|
|
* @author fenris
|
|
* @todo schön machen? is aber vermutlich gar nicht möglich :/
|
|
*/
|
|
function lexerrule_show(rule) {
|
|
return "(nicht darstellbar)";
|
|
}
|
|
lang.lexerrule_show = lexerrule_show;
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
function lexerrule_apply(rule, tokens) {
|
|
/**
|
|
* @todo Wert sollte konfigurierbar sein
|
|
*/
|
|
let maximum = (1 << 10);
|
|
lib_observer.notify(rule.observer, "start", { "rule": rule });
|
|
let offset = 0;
|
|
// process _all_ occurences
|
|
while (true) {
|
|
lib_observer.notify(rule.observer, "message_sequence", { "tokens": tokens });
|
|
if (maximum-- <= 0) {
|
|
lib_observer.notify(rule.observer, "maximum_reached", {});
|
|
break;
|
|
}
|
|
let found = tokens.slice(offset).some(function (token_old, index) {
|
|
if (token_old.terminal.is_just()) {
|
|
return false;
|
|
}
|
|
else {
|
|
let result = rule.search(token_old.sequence);
|
|
if (!result.found) {
|
|
return false;
|
|
}
|
|
else {
|
|
// der Ersatz für den Platz von "token_old"
|
|
let tokens_new = [];
|
|
// die Zeichen des alten Tokens, die vor der Übereinstimmung stehen
|
|
{
|
|
let nonempty = (result.data.position > 0);
|
|
if (nonempty) {
|
|
let sequence = token_old.sequence.slice(0, result.data.position);
|
|
tokens_new.push({
|
|
"sequence": sequence,
|
|
"terminal": new class_nothing(),
|
|
});
|
|
}
|
|
}
|
|
// die Zeichen der Übereinstimmung
|
|
{
|
|
let sequence = token_old.sequence.slice(result.data.position, result.data.position + result.data.length);
|
|
let terminals = rule.construct(sequence);
|
|
terminals.forEach((terminal) => {
|
|
tokens_new.push({
|
|
"sequence": null,
|
|
"terminal": new class_just(terminal),
|
|
});
|
|
});
|
|
}
|
|
// die Zeichen des alten Tokens, die hinter der Übereinstimmung stehen
|
|
{
|
|
let nonempty = (result.data.position + result.data.length < token_old.sequence.length);
|
|
if (nonempty) {
|
|
let sequence = token_old.sequence.slice(result.data.position + result.data.length /*,
|
|
token_old.sequence.length*/);
|
|
tokens_new.push({
|
|
"sequence": sequence,
|
|
"terminal": new class_nothing(),
|
|
});
|
|
}
|
|
}
|
|
/*
|
|
console.log("-- offset_old: ", offset);
|
|
console.log("-- index: ", index);
|
|
console.log("-- token_old: ", token_old);
|
|
offset += index;
|
|
console.log("-- offset_new: ", offset);
|
|
*/
|
|
tokens = []
|
|
.concat(tokens.slice(0, index))
|
|
.concat(tokens_new)
|
|
.concat(tokens.slice(index + 1));
|
|
return true;
|
|
}
|
|
}
|
|
});
|
|
if (!found) {
|
|
break;
|
|
}
|
|
}
|
|
return tokens;
|
|
}
|
|
lang.lexerrule_apply = lexerrule_apply;
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
function lexerrule_pass() {
|
|
return lexerrule_make((part) => ({ "found": true, "data": { "position": 0, "length": 1 } }), (part) => part);
|
|
}
|
|
lang.lexerrule_pass = lexerrule_pass;
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
function lexerrule_pattern_generic(rule_raw) {
|
|
let regexp = new RegExp(rule_raw.pattern);
|
|
return lexerrule_make((part) => {
|
|
const part_ = part.join("");
|
|
// console.log(`searching for '${regexp.toString()}' in '${part_}' ...`);
|
|
const match_ = regexp.exec(part_);
|
|
// console.log(`... result: `, match_);
|
|
if (match_ == null) {
|
|
return { "found": false };
|
|
}
|
|
else {
|
|
return { "found": true, "data": { "position": match_.index, "length": match_[0].length } };
|
|
}
|
|
}, rule_raw.construct);
|
|
}
|
|
lang.lexerrule_pattern_generic = lexerrule_pattern_generic;
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
function lexerrule_pattern_ignore(pattern) {
|
|
return (lexerrule_pattern_generic({
|
|
"pattern": pattern,
|
|
"construct": tokens => []
|
|
}));
|
|
}
|
|
lang.lexerrule_pattern_ignore = lexerrule_pattern_ignore;
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
function lexerrule_pattern_void(pattern, id) {
|
|
return (lexerrule_pattern_generic({
|
|
"pattern": pattern,
|
|
"construct": tokens => [{ "id": id, "data": {} }],
|
|
}));
|
|
}
|
|
lang.lexerrule_pattern_void = lexerrule_pattern_void;
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
function lexerrule_pattern_boolean(pattern, id, value) {
|
|
return (lexerrule_pattern_generic({
|
|
"pattern": pattern,
|
|
"construct": tokens => [{ "id": id, "data": { "value": value } }],
|
|
}));
|
|
}
|
|
lang.lexerrule_pattern_boolean = lexerrule_pattern_boolean;
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
function lexerrule_pattern_int(pattern, id) {
|
|
return (lexerrule_pattern_generic({
|
|
"pattern": pattern,
|
|
"construct": tokens => [{ "id": id, "data": { "value": parseInt(tokens.join("")) } }],
|
|
}));
|
|
}
|
|
lang.lexerrule_pattern_int = lexerrule_pattern_int;
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
function lexerrule_pattern_float(pattern, id) {
|
|
return (lexerrule_pattern_generic({
|
|
"pattern": pattern,
|
|
"construct": tokens => [{ "id": id, "data": { "value": parseFloat(tokens.join("")) } }],
|
|
}));
|
|
}
|
|
lang.lexerrule_pattern_float = lexerrule_pattern_float;
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
function lexerrule_pattern_string(pattern, id) {
|
|
return (lexerrule_pattern_generic({
|
|
"pattern": pattern,
|
|
"construct": tokens => [{ "id": id, "data": { "value": tokens.join("") } }],
|
|
}));
|
|
}
|
|
lang.lexerrule_pattern_string = lexerrule_pattern_string;
|
|
})(lang = lib_plankton.lang || (lib_plankton.lang = {}));
|
|
})(lib_plankton || (lib_plankton = {}));
|
|
/*
|
|
This file is part of »bacterio-plankton:lang«.
|
|
|
|
Copyright 2016-2021 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
|
|
<info@greenscale.de>
|
|
|
|
»bacterio-plankton:lang« is free software: you can redistribute it and/or modify
|
|
it under the terms of the GNU Lesser General Public License as published by
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
»bacterio-plankton:lang« is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU Lesser General Public License for more details.
|
|
|
|
You should have received a copy of the GNU Lesser General Public License
|
|
along with »bacterio-plankton:lang«. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
var lib_plankton;
|
|
(function (lib_plankton) {
|
|
var lang;
|
|
(function (lang) {
|
|
/*
|
|
-- input
|
|
[("0 & !0",—)]
|
|
-- ws
|
|
[("0",—),("& !0",—)]
|
|
[("0",—),("&",—),("!0",—)]
|
|
-- const
|
|
[("0",<false>),("&",—),("!0",—)]
|
|
[("0",<false>),("&",—),("!",—),("0",<false>)]
|
|
-- not
|
|
[("0",<false>),("&",—),("!",<not>),("0",<false>)]
|
|
-- and
|
|
[("0",<false>),("&",<and>),("!",<not>),("0",<false>)]
|
|
*/
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
function lexer_dumb_make(rules) {
|
|
let observer = lib_observer.make();
|
|
lib_observer.register(observer, "start");
|
|
lib_observer.register(observer, "fail");
|
|
lib_observer.attend(observer, "start", ({ "input": input }) => {
|
|
lib_plankton.log.info("lib_plankton.lang:lexer:run:begin", {
|
|
"input": input,
|
|
});
|
|
});
|
|
lib_observer.attend(observer, "fail", ({ "open": open }) => {
|
|
lib_plankton.log.warning("lib_plankton.lang:lexer:run:fail", {
|
|
"sequence": open.map(token => String(token.sequence)),
|
|
});
|
|
});
|
|
return {
|
|
"rules": rules,
|
|
"observer": observer,
|
|
};
|
|
}
|
|
lang.lexer_dumb_make = lexer_dumb_make;
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
function lexer_dumb_run(subject, input, configuration = {
|
|
"use_reduce": false,
|
|
}) {
|
|
lib_observer.notify(subject.observer, "start", { "input": input });
|
|
let tokens;
|
|
if (configuration.use_reduce) {
|
|
tokens = subject.rules.reduce((tokens, rule) => lang.lexerrule_apply(rule, tokens), [
|
|
{
|
|
"sequence": input,
|
|
"terminal": new class_nothing(),
|
|
}
|
|
]);
|
|
}
|
|
else {
|
|
tokens = [
|
|
{
|
|
"sequence": input,
|
|
"terminal": new class_nothing(),
|
|
}
|
|
];
|
|
subject.rules.forEach((rule) => (tokens = lang.lexerrule_apply(rule, tokens)));
|
|
}
|
|
let open = tokens.filter(token => token.terminal.is_nothing());
|
|
if (open.length > 0) {
|
|
lib_observer.notify(subject.observer, "fail", { "open": open });
|
|
throw (new Error("failed"));
|
|
}
|
|
else {
|
|
return tokens.map(token => token.terminal.cull());
|
|
}
|
|
}
|
|
lang.lexer_dumb_run = lexer_dumb_run;
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
function lexer_dumb_pass() {
|
|
return lexer_dumb_make([
|
|
lang.lexerrule_pass(),
|
|
]);
|
|
}
|
|
lang.lexer_dumb_pass = lexer_dumb_pass;
|
|
})(lang = lib_plankton.lang || (lib_plankton.lang = {}));
|
|
})(lib_plankton || (lib_plankton = {}));
|
|
/*
|
|
This file is part of »bacterio-plankton:lang«.
|
|
|
|
Copyright 2016-2021 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
|
|
<info@greenscale.de>
|
|
|
|
»bacterio-plankton:lang« is free software: you can redistribute it and/or modify
|
|
it under the terms of the GNU Lesser General Public License as published by
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
»bacterio-plankton:lang« is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU Lesser General Public License for more details.
|
|
|
|
You should have received a copy of the GNU Lesser General Public License
|
|
along with »bacterio-plankton:lang«. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
var lib_plankton;
|
|
(function (lib_plankton) {
|
|
var lang;
|
|
(function (lang) {
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
class class_lexerrule {
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
constructor(subject) {
|
|
this.subject = subject;
|
|
}
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
static construct({ "search": search, "construct": construct, }) {
|
|
let subject = lang.lexerrule_make(search, construct);
|
|
return (new class_lexerrule(subject));
|
|
}
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
subject_get() {
|
|
return this.subject;
|
|
}
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
search(part) {
|
|
return this.subject.search(part);
|
|
}
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
construct(part) {
|
|
return this.subject.construct(part);
|
|
}
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
static pass() {
|
|
return (new class_lexerrule(lang.lexerrule_pass()));
|
|
}
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
static pattern_generic(rule_raw) {
|
|
return (new class_lexerrule(lang.lexerrule_pattern_generic(rule_raw)));
|
|
}
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
static pattern_ignore(pattern) {
|
|
return (new class_lexerrule(lang.lexerrule_pattern_ignore(pattern)));
|
|
}
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
static pattern_void(pattern, id) {
|
|
return (new class_lexerrule(lang.lexerrule_pattern_void(pattern, id)));
|
|
}
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
static pattern_boolean(pattern, id, value) {
|
|
return (new class_lexerrule(lang.lexerrule_pattern_boolean(pattern, id, value)));
|
|
}
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
static pattern_int(pattern, id) {
|
|
return (new class_lexerrule(lang.lexerrule_pattern_int(pattern, id)));
|
|
}
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
static pattern_float(pattern, id) {
|
|
return (new class_lexerrule(lang.lexerrule_pattern_float(pattern, id)));
|
|
}
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
static pattern_string(pattern, id) {
|
|
return (new class_lexerrule(lang.lexerrule_pattern_string(pattern, id)));
|
|
}
|
|
}
|
|
lang.class_lexerrule = class_lexerrule;
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
class class_lexer_dumb {
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
constructor(subject) {
|
|
this.subject = subject;
|
|
}
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
static construct(rules) {
|
|
const subject = lang.lexer_dumb_make(rules.map(rule => rule.subject_get()));
|
|
return (new class_lexer_dumb(subject));
|
|
}
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
run(input) {
|
|
return lang.lexer_dumb_run(this.subject, input);
|
|
}
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
static pass() {
|
|
return (new class_lexer_dumb(lang.lexer_dumb_pass()));
|
|
}
|
|
}
|
|
lang.class_lexer_dumb = class_lexer_dumb;
|
|
})(lang = lib_plankton.lang || (lib_plankton.lang = {}));
|
|
})(lib_plankton || (lib_plankton = {}));
|
|
/*
|
|
This file is part of »bacterio-plankton:lang«.
|
|
|
|
Copyright 2016-2021 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
|
|
<info@greenscale.de>
|
|
|
|
»bacterio-plankton:lang« is free software: you can redistribute it and/or modify
|
|
it under the terms of the GNU Lesser General Public License as published by
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
»bacterio-plankton:lang« is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU Lesser General Public License for more details.
|
|
|
|
You should have received a copy of the GNU Lesser General Public License
|
|
along with »bacterio-plankton:lang«. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
/*
|
|
This file is part of »bacterio-plankton:lang«.
|
|
|
|
Copyright 2016-2021 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
|
|
<info@greenscale.de>
|
|
|
|
»bacterio-plankton:lang« is free software: you can redistribute it and/or modify
|
|
it under the terms of the GNU Lesser General Public License as published by
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
»bacterio-plankton:lang« is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU Lesser General Public License for more details.
|
|
|
|
You should have received a copy of the GNU Lesser General Public License
|
|
along with »bacterio-plankton:lang«. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
var lib_plankton;
|
|
(function (lib_plankton) {
|
|
var lang;
|
|
(function (lang) {
|
|
/**
|
|
* @desc [constructor]
|
|
* @author fenris
|
|
*/
|
|
function parserrule_make({ "premise": premise, "conclusion": conclusion, "construct": construct, "right_to_left": right_to_left = false, }) {
|
|
return {
|
|
"premise": premise,
|
|
"conclusion": conclusion,
|
|
"construct": construct,
|
|
"right_to_left": right_to_left,
|
|
};
|
|
}
|
|
lang.parserrule_make = parserrule_make;
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
function parserrule_check(parserrule, sequence) {
|
|
let position = lang.find(sequence, parserrule.conclusion, (x, y) => x.equals(y), parserrule.right_to_left);
|
|
return position;
|
|
}
|
|
lang.parserrule_check = parserrule_check;
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
function parserrule_construct(parserrule, args, terminals) {
|
|
return parserrule.construct(args, terminals);
|
|
}
|
|
lang.parserrule_construct = parserrule_construct;
|
|
})(lang = lib_plankton.lang || (lib_plankton.lang = {}));
|
|
})(lib_plankton || (lib_plankton = {}));
|
|
/*
|
|
This file is part of »bacterio-plankton:lang«.
|
|
|
|
Copyright 2016-2021 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
|
|
<info@greenscale.de>
|
|
|
|
»bacterio-plankton:lang« is free software: you can redistribute it and/or modify
|
|
it under the terms of the GNU Lesser General Public License as published by
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
»bacterio-plankton:lang« is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU Lesser General Public License for more details.
|
|
|
|
You should have received a copy of the GNU Lesser General Public License
|
|
along with »bacterio-plankton:lang«. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
var lib_plankton;
|
|
(function (lib_plankton) {
|
|
var lang;
|
|
(function (lang) {
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
function parser_dumb_make(start, rules, equality_terminal = ((x, y) => (x == y))) {
|
|
let observer = lib_observer.make();
|
|
lib_observer.register(observer, "start");
|
|
lib_observer.register(observer, "message_sequence");
|
|
lib_observer.register(observer, "use_rule");
|
|
lib_observer.register(observer, "fail");
|
|
lib_observer.attend(observer, "start", ({ "input": input }) => {
|
|
lib_plankton.log.info("lib_plankton.lang:parser:run:begin", {
|
|
"input": input
|
|
});
|
|
});
|
|
lib_observer.attend(observer, "message_sequence", ({ "sequence": sequence }) => {
|
|
lib_plankton.log.debug("lib_plankton.lang:parser:run:current_sequence", {
|
|
"tokens": sequence,
|
|
});
|
|
});
|
|
lib_observer.attend(observer, "use_rule", ({ "rule": rule, "conclusion": conclusion }) => {
|
|
lib_plankton.log.debug("lib_plankton.lang:parser:run:using_the_following_rule", {
|
|
"conclusion": conclusion.map(symbol => symbol.toString()),
|
|
"premise": rule.premise.toString(),
|
|
});
|
|
});
|
|
lib_observer.attend(observer, "fail", ({ "sequence": sequence }) => {
|
|
lib_plankton.log.error("lib_plankton.lang:parser:run:failed", {
|
|
"last_sequence": sequence,
|
|
});
|
|
});
|
|
return {
|
|
"start": start,
|
|
"rules": rules,
|
|
"equality_terminal": equality_terminal,
|
|
"observer": observer,
|
|
};
|
|
}
|
|
lang.parser_dumb_make = parser_dumb_make;
|
|
/**
|
|
* @override
|
|
* @author fenris
|
|
*/
|
|
function parser_dumb_run(parser_dumb, input, target_variable) {
|
|
if (target_variable === undefined) {
|
|
target_variable = parser_dumb.start;
|
|
}
|
|
lib_observer.notify(parser_dumb.observer, "start", { "input": input });
|
|
let maximum = (1 << 10);
|
|
let current = (input
|
|
.map((terminal) => {
|
|
return (new lang.class_symbol_terminal(terminal, parser_dumb.equality_terminal));
|
|
}));
|
|
while (true) {
|
|
lib_observer.notify(parser_dumb.observer, "message_sequence", { "sequence": current });
|
|
if (maximum-- <= 0) {
|
|
break;
|
|
}
|
|
const found = parser_dumb.rules.some(function (rule, index) {
|
|
let conclusion = rule.conclusion;
|
|
let position = lang.parserrule_check(rule, current);
|
|
if (position >= 0) {
|
|
lib_observer.notify(parser_dumb.observer, "use_rule", { "rule": rule, "conclusion": conclusion });
|
|
let terminals = (current
|
|
.slice(position, position + conclusion.length)
|
|
.filter(x => (x instanceof lang.class_symbol_terminal /*<type_terminal, type_variable, type_meaning>*/))
|
|
.map(element => (element).terminal_get()));
|
|
let args = (current
|
|
.slice(position, position + conclusion.length)
|
|
.filter(x => (x instanceof lang.class_symbol_variable /*<type_terminal, type_variable, type_meaning>*/))
|
|
.map(element => (element).meaning_get()));
|
|
let meaning = rule.construct(args, terminals);
|
|
let symbol = (new lang.class_symbol_variable(rule.premise, meaning));
|
|
current = ([]
|
|
.concat(current.slice(0, position))
|
|
.concat([symbol])
|
|
.concat(current.slice(position + conclusion.length)));
|
|
return true;
|
|
}
|
|
else {
|
|
return false;
|
|
}
|
|
});
|
|
if (!found) {
|
|
break;
|
|
}
|
|
}
|
|
if ((current.length == 1)
|
|
&&
|
|
(current[0] instanceof lang.class_symbol_variable /*<type_terminal, type_variable, type_meaning>*/)
|
|
&&
|
|
((current[0]).variable_get() === target_variable)) {
|
|
return (current[0]).meaning_get();
|
|
}
|
|
else {
|
|
lib_observer.notify(parser_dumb.observer, "fail", { "sequence": current });
|
|
/*
|
|
console.warn("--", "parsing failed");
|
|
console.info("--", "last sequence was:"); current.forEach(element => console.info(element));
|
|
*/
|
|
// return null;
|
|
throw (new Error("parsing failed"));
|
|
}
|
|
}
|
|
lang.parser_dumb_run = parser_dumb_run;
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
function parser_dumb_tree(start, rules_raw, equality_terminal = ((x, y) => (x == y))) {
|
|
return (parser_dumb_make(start, rules_raw.map((rule_raw) => {
|
|
return (lang.parserrule_make({
|
|
"premise": rule_raw.premise,
|
|
"conclusion": rule_raw.conclusion,
|
|
"construct": (args, tokens) => {
|
|
return {
|
|
"label": rule_raw.label,
|
|
"value": tokens,
|
|
"children": args,
|
|
};
|
|
},
|
|
"right_to_left": rule_raw.right_to_left,
|
|
}));
|
|
}), equality_terminal));
|
|
}
|
|
lang.parser_dumb_tree = parser_dumb_tree;
|
|
})(lang = lib_plankton.lang || (lib_plankton.lang = {}));
|
|
})(lib_plankton || (lib_plankton = {}));
|
|
/*
|
|
This file is part of »bacterio-plankton:lang«.
|
|
|
|
Copyright 2016-2021 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
|
|
<info@greenscale.de>
|
|
|
|
»bacterio-plankton:lang« is free software: you can redistribute it and/or modify
|
|
it under the terms of the GNU Lesser General Public License as published by
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
»bacterio-plankton:lang« is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU Lesser General Public License for more details.
|
|
|
|
You should have received a copy of the GNU Lesser General Public License
|
|
along with »bacterio-plankton:lang«. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
var lib_plankton;
|
|
(function (lib_plankton) {
|
|
var lang;
|
|
(function (lang) {
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
class class_parserrule {
|
|
/**
|
|
* @desc [constructor]
|
|
* @author fenris
|
|
*/
|
|
constructor(subject) {
|
|
this.subject = subject;
|
|
}
|
|
/**
|
|
* @desc [constructor]
|
|
* @author fenris
|
|
*/
|
|
static construct({ "premise": premise, "conclusion": conclusion, "construct": construct, "right_to_left": right_to_left = false, }) {
|
|
return (new class_parserrule({
|
|
"premise": premise,
|
|
"conclusion": conclusion,
|
|
"construct": construct,
|
|
"right_to_left": right_to_left,
|
|
}));
|
|
}
|
|
/**
|
|
* @desc [accessor] [getter]
|
|
* @author fenris
|
|
*/
|
|
subject_get() {
|
|
return this.subject;
|
|
}
|
|
/**
|
|
* @desc [accessor] [getter]
|
|
* @author fenris
|
|
*/
|
|
premise_get() {
|
|
return this.subject.premise;
|
|
}
|
|
/**
|
|
* @desc [accessor] [getter]
|
|
* @author fenris
|
|
*/
|
|
conclusion_get() {
|
|
return this.subject.conclusion;
|
|
}
|
|
/**
|
|
* @desc [accessor]
|
|
* @author fenris
|
|
*/
|
|
check(sequence) {
|
|
return (lang.parserrule_check(this.subject, sequence));
|
|
}
|
|
/**
|
|
* @desc [accessor]
|
|
* @author fenris
|
|
*/
|
|
construct(args, terminals) {
|
|
return (lang.parserrule_construct(this.subject, args, terminals));
|
|
}
|
|
}
|
|
lang.class_parserrule = class_parserrule;
|
|
/**
|
|
* @author fenris
|
|
* @todo fatal error on empty conclusion
|
|
*/
|
|
class class_parser_dumb {
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
constructor(subject) {
|
|
this.subject = subject;
|
|
}
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
static construct(start, rules, equality_terminal = ((x, y) => (x == y))) {
|
|
const subject = lang.parser_dumb_make(start, rules.map(rule => rule.subject_get()), equality_terminal);
|
|
return (new class_parser_dumb(subject));
|
|
}
|
|
/**
|
|
* @override
|
|
* @author fenris
|
|
*/
|
|
run(input, target_variable) {
|
|
return lang.parser_dumb_run(this.subject, input, target_variable);
|
|
}
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
static tree(start, rules_raw, equality_terminal = ((x, y) => (x == y))) {
|
|
return (new class_parser_dumb(lang.parser_dumb_tree(start, rules_raw, equality_terminal)));
|
|
}
|
|
}
|
|
lang.class_parser_dumb = class_parser_dumb;
|
|
})(lang = lib_plankton.lang || (lib_plankton.lang = {}));
|
|
})(lib_plankton || (lib_plankton = {}));
|
|
/*
|
|
This file is part of »bacterio-plankton:lang«.
|
|
|
|
Copyright 2016-2021 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
|
|
<info@greenscale.de>
|
|
|
|
»bacterio-plankton:lang« is free software: you can redistribute it and/or modify
|
|
it under the terms of the GNU Lesser General Public License as published by
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
»bacterio-plankton:lang« is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU Lesser General Public License for more details.
|
|
|
|
You should have received a copy of the GNU Lesser General Public License
|
|
along with »bacterio-plankton:lang«. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
var lib_plankton;
|
|
(function (lib_plankton) {
|
|
var lang;
|
|
(function (lang) {
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
function reader_run(lexer_run, parser_run, input, target_variable) {
|
|
const syntax = lexer_run(input);
|
|
lib_plankton.log.info("lib_plankton.lang:reader:syntax", {
|
|
"syntax": syntax,
|
|
});
|
|
const semantics = parser_run(syntax, target_variable);
|
|
lib_plankton.log.info("lib_plankton.lang:reader:semantics", {
|
|
"semantics": semantics,
|
|
});
|
|
return semantics;
|
|
}
|
|
lang.reader_run = reader_run;
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
function reader_default({ "lexer_rules": lexer_rules, "parser_start": parser_start, "parser_rules": parser_rules, }) {
|
|
return (new lib_plankton.lang.class_reader(lang.class_lexer_dumb.construct(lexer_rules), lang.class_parser_dumb.tree(parser_start, parser_rules, (x, y) => (x.id == y.id))));
|
|
}
|
|
lang.reader_default = reader_default;
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
function default_raw({ "lexer_rules": lexer_rules, "parser_start": parser_start, "parser_rules": parser_rules, }) {
|
|
return (this.default({
|
|
"lexer_rules": lexer_rules.map((lexerrule_raw) => {
|
|
switch (lexerrule_raw.type) {
|
|
case "ignore": {
|
|
return lang.class_lexerrule.pattern_ignore(lexerrule_raw.parameters["pattern"]);
|
|
break;
|
|
}
|
|
case "void": {
|
|
return lang.class_lexerrule.pattern_void(lexerrule_raw.parameters["pattern"], lexerrule_raw.parameters["id"]);
|
|
break;
|
|
}
|
|
case "boolean": {
|
|
return lang.class_lexerrule.pattern_boolean(lexerrule_raw.parameters["pattern"], lexerrule_raw.parameters["id"], lexerrule_raw.parameters["value"]);
|
|
break;
|
|
}
|
|
case "int": {
|
|
return lang.class_lexerrule.pattern_int(lexerrule_raw.parameters["pattern"], lexerrule_raw.parameters["id"]);
|
|
break;
|
|
}
|
|
case "float": {
|
|
return lang.class_lexerrule.pattern_float(lexerrule_raw.parameters["pattern"], lexerrule_raw.parameters["id"]);
|
|
break;
|
|
}
|
|
case "string": {
|
|
return lang.class_lexerrule.pattern_string(lexerrule_raw.parameters["pattern"], lexerrule_raw.parameters["id"]);
|
|
break;
|
|
}
|
|
default: {
|
|
throw (new Error(`unhandled type for raw lexer-rule '${lexerrule_raw.type}'`));
|
|
break;
|
|
}
|
|
}
|
|
}),
|
|
"parser_start": parser_start,
|
|
"parser_rules": parser_rules.map((parserrule_raw) => {
|
|
return ({
|
|
"label": parserrule_raw.label,
|
|
"premise": parserrule_raw.premise,
|
|
"conclusion": parserrule_raw.conclusion.map(entry => {
|
|
switch (entry.type) {
|
|
case "terminal": {
|
|
return (new lib_plankton.lang.class_symbol_terminal({ "id": entry.parameters["id"] }));
|
|
break;
|
|
}
|
|
case "variable": {
|
|
return (new lib_plankton.lang.class_symbol_variable(entry.parameters["id"]));
|
|
break;
|
|
}
|
|
default: {
|
|
throw (new Error(`unhandled type for raw parser-rule '${entry.type}'`));
|
|
break;
|
|
}
|
|
}
|
|
}),
|
|
"right_to_left": parserrule_raw.right_to_left,
|
|
});
|
|
}),
|
|
}));
|
|
}
|
|
lang.default_raw = default_raw;
|
|
})(lang = lib_plankton.lang || (lib_plankton.lang = {}));
|
|
})(lib_plankton || (lib_plankton = {}));
|
|
/*
|
|
This file is part of »bacterio-plankton:lang«.
|
|
|
|
Copyright 2016-2021 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
|
|
<info@greenscale.de>
|
|
|
|
»bacterio-plankton:lang« is free software: you can redistribute it and/or modify
|
|
it under the terms of the GNU Lesser General Public License as published by
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
»bacterio-plankton:lang« is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU Lesser General Public License for more details.
|
|
|
|
You should have received a copy of the GNU Lesser General Public License
|
|
along with »bacterio-plankton:lang«. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
var lib_plankton;
|
|
(function (lib_plankton) {
|
|
var lang;
|
|
(function (lang) {
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
class class_reader {
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
constructor(lexer, parser) {
|
|
this.lexer = lexer;
|
|
this.parser = parser;
|
|
}
|
|
/**
|
|
* @desc [accessor] yes, it's really just lexing and parsing
|
|
* @author fenris
|
|
*/
|
|
run(input, target_variable) {
|
|
/*
|
|
const syntax : Array<type_terminal> = this.lexer.run(input);
|
|
lib_plankton.log.info(
|
|
"lang:reader:syntax",
|
|
{
|
|
"syntax": syntax,
|
|
}
|
|
);
|
|
const semantics : type_result = this.parser.run(syntax, target_variable);
|
|
lib_plankton.log.info(
|
|
"lang:reader:semantics",
|
|
{
|
|
"semantics": semantics,
|
|
}
|
|
);
|
|
return semantics;
|
|
*/
|
|
return lang.reader_run((input) => this.lexer.run(input), (input, target_variable) => this.parser.run(input, target_variable), input, target_variable);
|
|
}
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
static default({ "lexer_rules": lexer_rules, "parser_start": parser_start, "parser_rules": parser_rules, }) {
|
|
return (new lib_plankton.lang.class_reader(lang.class_lexer_dumb.construct(lexer_rules), lang.class_parser_dumb.tree(parser_start, parser_rules, (x, y) => (x.id == y.id))));
|
|
}
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
static default_raw({ "lexer_rules": lexer_rules, "parser_start": parser_start, "parser_rules": parser_rules, }) {
|
|
return (this.default({
|
|
"lexer_rules": lexer_rules.map((lexerrule_raw) => {
|
|
switch (lexerrule_raw.type) {
|
|
case "ignore": {
|
|
return lang.class_lexerrule.pattern_ignore(lexerrule_raw.parameters["pattern"]);
|
|
break;
|
|
}
|
|
case "void": {
|
|
return lang.class_lexerrule.pattern_void(lexerrule_raw.parameters["pattern"], lexerrule_raw.parameters["id"]);
|
|
break;
|
|
}
|
|
case "boolean": {
|
|
return lang.class_lexerrule.pattern_boolean(lexerrule_raw.parameters["pattern"], lexerrule_raw.parameters["id"], lexerrule_raw.parameters["value"]);
|
|
break;
|
|
}
|
|
case "int": {
|
|
return lang.class_lexerrule.pattern_int(lexerrule_raw.parameters["pattern"], lexerrule_raw.parameters["id"]);
|
|
break;
|
|
}
|
|
case "float": {
|
|
return lang.class_lexerrule.pattern_float(lexerrule_raw.parameters["pattern"], lexerrule_raw.parameters["id"]);
|
|
break;
|
|
}
|
|
case "string": {
|
|
return lang.class_lexerrule.pattern_string(lexerrule_raw.parameters["pattern"], lexerrule_raw.parameters["id"]);
|
|
break;
|
|
}
|
|
default: {
|
|
throw (new Error(`unhandled type for raw lexer-rule '${lexerrule_raw.type}'`));
|
|
break;
|
|
}
|
|
}
|
|
}),
|
|
"parser_start": parser_start,
|
|
"parser_rules": parser_rules.map((parserrule_raw) => {
|
|
return ({
|
|
"label": parserrule_raw.label,
|
|
"premise": parserrule_raw.premise,
|
|
"conclusion": parserrule_raw.conclusion.map(entry => {
|
|
switch (entry.type) {
|
|
case "terminal": {
|
|
return (new lib_plankton.lang.class_symbol_terminal({ "id": entry.parameters["id"] }));
|
|
break;
|
|
}
|
|
case "variable": {
|
|
return (new lib_plankton.lang.class_symbol_variable(entry.parameters["id"]));
|
|
break;
|
|
}
|
|
default: {
|
|
throw (new Error(`unhandled type for raw parser-rule '${entry.type}'`));
|
|
break;
|
|
}
|
|
}
|
|
}),
|
|
"right_to_left": parserrule_raw.right_to_left,
|
|
});
|
|
}),
|
|
}));
|
|
}
|
|
}
|
|
lang.class_reader = class_reader;
|
|
})(lang = lib_plankton.lang || (lib_plankton.lang = {}));
|
|
})(lib_plankton || (lib_plankton = {}));
|