140 lines
3.7 KiB
TypeScript
140 lines
3.7 KiB
TypeScript
/*
|
|
This file is part of »type2«.
|
|
|
|
Copyright 2016-2021 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
|
|
<info@greenscale.de>
|
|
|
|
»type2« 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.
|
|
|
|
»type2« 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 »type2«. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
type type_resulttree = lib_plankton.lang.type_tree<lib_plankton.lang.type_terminal_default>;
|
|
|
|
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
type type_myreader = lib_plankton.lang.class_reader<char, lib_plankton.lang.type_terminal_default, string, type_resulttree>;
|
|
|
|
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
async function generate_reader(
|
|
path : string
|
|
) : Promise<type_myreader>
|
|
{
|
|
const content : string = await lib_plankton.file.read(path);
|
|
const data : any = JSON.parse(content);
|
|
const reader : type_myreader = lib_plankton.lang.class_reader.default_raw(data);
|
|
return Promise.resolve<type_myreader>(reader);
|
|
}
|
|
|
|
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
async function main(
|
|
args_raw : Array<string>
|
|
) : Promise<void>
|
|
{
|
|
const args_handler : lib_args.class_handler = new lib_args.class_handler({
|
|
"path": lib_args.class_argument.positional({
|
|
"index": 0,
|
|
"type": lib_args.enum_type.string,
|
|
"mode": lib_args.enum_mode.replace,
|
|
"info": "the path to the grammar file",
|
|
"name": "path",
|
|
}),
|
|
"verbosity": lib_args.class_argument.volatile({
|
|
"indicators_short": ["v"],
|
|
"indicators_long": ["verbosity"],
|
|
"type": lib_args.enum_type.integer,
|
|
"mode": lib_args.enum_mode.replace,
|
|
"default": 1,
|
|
"info": "verbosity level",
|
|
"name": "verbosity",
|
|
}),
|
|
"help": lib_args.class_argument.volatile({
|
|
"indicators_short": ["h"],
|
|
"indicators_long": ["help"],
|
|
"type": lib_args.enum_type.boolean,
|
|
"mode": lib_args.enum_mode.replace,
|
|
"default": false,
|
|
"info": "show help and exit",
|
|
"name": "help",
|
|
}),
|
|
});
|
|
const args : Record<string, any> = args_handler.read(lib_args.enum_environment.cli, args_raw.join(" "));
|
|
if (args["help"]) {
|
|
process.stdout.write(
|
|
args_handler.generate_help({
|
|
"programname": "type2",
|
|
"description": "reads a string from stdin and parses it according to a given grammar to an abstract syntax tree as JSON",
|
|
"author": "Christian Fraß <frass@greenscale.de>",
|
|
"executable": "type2",
|
|
})
|
|
);
|
|
return Promise.resolve<void>(undefined);
|
|
}
|
|
else {
|
|
lib_plankton.log.conf_push(
|
|
(args["verbosity"] <= 0)
|
|
? []
|
|
: [
|
|
new lib_plankton.log.class_channel_minlevel(
|
|
new lib_plankton.log.class_channel_console(),
|
|
[
|
|
lib_plankton.log.enum_level.error,
|
|
lib_plankton.log.enum_level.warning,
|
|
lib_plankton.log.enum_level.notice,
|
|
lib_plankton.log.enum_level.info,
|
|
lib_plankton.log.enum_level.debug,
|
|
][args["verbosity"]-1]
|
|
),
|
|
]
|
|
);
|
|
|
|
// exec
|
|
const reader : type_myreader = await generate_reader(args["path"]);
|
|
const input_raw : string = await lib_plankton.file.read_stdin();
|
|
const result : type_resulttree = reader.run(input_raw.split(""));
|
|
if (result === null) {
|
|
return Promise.reject<void>(new Error("reading failed"));
|
|
}
|
|
else {
|
|
process.stdout.write(JSON.stringify(result, undefined, "\t") + "\n");
|
|
return Promise.resolve<void>(undefined);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
main(process.argv.slice(2))
|
|
.then(
|
|
() => {
|
|
// process.stderr.write("done");
|
|
},
|
|
(error) => {
|
|
process.stderr.write(error.toString() + "\n");
|
|
}
|
|
);
|
|
|