jschaufuss/DiceCloud
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge feature-nested-sets into develop

Browse Source
This commit is contained in:
ThaumRystra
2023-12-18 18:27:17 +02:00
parent 1e90b345e2 6e0364b636
commit 3ba603407e
523 changed files with 5492 additions and 3763 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
app/imports/parser/functions.js
View File

@@ -1,5 +1,5 @@
import resolve from '/imports/parser/resolve.js'
import rollDice from '/imports/parser/rollDice.js';
import resolve from '/imports/parser/resolve'
import rollDice from '/imports/parser/rollDice';
export default {
'abs': {

247
app/imports/parser/grammar.js
View File

@@ -2,132 +2,137 @@
// http://github.com/Hardmath123/nearley
function id(x) { return x[0]; }
import node from './parseTree/_index.js';
import node from './parseTree/_index';
import moo from 'moo';
import moo from 'moo';
const lexer = moo.compile({
number: /[0-9]+(?:\.[0-9]+)?/,
string: {
match: /'[^']*'|"[^"]*"/,
value: s => s.slice(1, -1).replace('\\n', '\n'),
},
name: {
match: /[~#]?[a-zA-Z]*[a-ce-zA-Z][a-zA-Z0-9_]*/,
type: moo.keywords({
'keywords': ['true', 'false'],
}),
},
space: {
match: /\s+/,
lineBreaks: true,
},
diceOperator: ['d'],
separator: [',', ';'],
period: ['.'],
ifOperator: ['?'],
elseOperator: [':'],
multiplicativeOperator: ['*', '/'],
exponentOperator: ['^'],
additiveOperator: ['+', '-'],
moduloOperator: ['%'],
andOperator: ['&', '&&'],
orOperator: ['|', '||'],
stringDelimiters: ['\"', '\''],
equalityOperator: ['=', '==', '===', '!=', '!=='],
notOperator: ['!'],
relationalOperator: ['>', '<', '>=', '<='],
brackets: ['(', ')', '{', '}', '[', ']'],
const lexer = moo.compile({
number: /[0-9]+(?:\.[0-9]+)?/,
string: {
match: /'[^']*'|"[^"]*"/,
value: s => s.slice(1, -1).replace('\\n', '\n'),
},
name: {
match: /[~#]?[a-zA-Z]*[a-ce-zA-Z][a-zA-Z0-9_]*/,
type: moo.keywords({
'keywords': ['true', 'false'],
}),
},
space: {
match: /\s+/,
lineBreaks: true,
},
diceOperator: ['d'],
separator: [',', ';'],
period: ['.'],
ifOperator: ['?'],
elseOperator: [':'],
multiplicativeOperator: ['*', '/'],
exponentOperator: ['^'],
additiveOperator: ['+', '-'],
moduloOperator: ['%'],
andOperator: ['&', '&&'],
orOperator: ['|', '||'],
stringDelimiters: ['\"', '\''],
equalityOperator: ['=', '==', '===', '!=', '!=='],
notOperator: ['!'],
relationalOperator: ['>', '<', '>=', '<='],
brackets: ['(', ')', '{', '}', '[', ']'],
});
function nuller() { return null; }
function operator([left, _1, operator, _2, right], fn) {
return node.operator.create({
left,
right,
operator: operator.value,
fn
});
function nuller() { return null; }
function operator([left, _1, operator, _2, right], fn){
return node.operator.create({
left,
right,
operator: operator.value,
fn
});
}
}
let Lexer = lexer;
let ParserRules = [
{"name": "spacedExpression", "symbols": ["_", "expression", "_"], "postprocess": d => d[1]},
{"name": "expression", "symbols": ["ifStatement"], "postprocess": id},
{"name": "ifStatement", "symbols": ["orExpression", "_", (lexer.has("ifOperator") ? {type: "ifOperator"} : ifOperator), "_", "orExpression", "_", (lexer.has("elseOperator") ? {type: "elseOperator"} : elseOperator), "_", "ifStatement"], "postprocess":
d => node.if.create({condition: d[0], consequent: d[4], alternative: d[8]})
},
{"name": "ifStatement", "symbols": ["orExpression"], "postprocess": id},
{"name": "orExpression", "symbols": ["orExpression", "_", (lexer.has("orOperator") ? {type: "orOperator"} : orOperator), "_", "andExpression"], "postprocess": d => operator(d, 'or')},
{"name": "orExpression", "symbols": ["andExpression"], "postprocess": id},
{"name": "andExpression", "symbols": ["andExpression", "_", (lexer.has("andOperator") ? {type: "andOperator"} : andOperator), "_", "equalityExpression"], "postprocess": d => operator(d, 'and')},
{"name": "andExpression", "symbols": ["equalityExpression"], "postprocess": id},
{"name": "equalityExpression", "symbols": ["equalityExpression", "_", (lexer.has("equalityOperator") ? {type: "equalityOperator"} : equalityOperator), "_", "relationalExpression"], "postprocess": d => operator(d, 'equality')},
{"name": "equalityExpression", "symbols": ["relationalExpression"], "postprocess": id},
{"name": "relationalExpression", "symbols": ["relationalExpression", "_", (lexer.has("relationalOperator") ? {type: "relationalOperator"} : relationalOperator), "_", "additiveExpression"], "postprocess": d => operator(d, 'relation')},
{"name": "relationalExpression", "symbols": ["additiveExpression"], "postprocess": id},
{"name": "additiveExpression", "symbols": ["additiveExpression", "_", (lexer.has("additiveOperator") ? {type: "additiveOperator"} : additiveOperator), "_", "remainderExpression"], "postprocess": d => operator(d, 'add')},
{"name": "additiveExpression", "symbols": ["remainderExpression"], "postprocess": id},
{"name": "remainderExpression", "symbols": ["remainderExpression", "_", (lexer.has("moduloOperator") ? {type: "moduloOperator"} : moduloOperator), "_", "multiplicativeExpression"], "postprocess": d => operator(d, 'remainder')},
{"name": "remainderExpression", "symbols": ["multiplicativeExpression"], "postprocess": id},
{"name": "multiplicativeExpression", "symbols": ["multiplicativeExpression", "_", (lexer.has("multiplicativeOperator") ? {type: "multiplicativeOperator"} : multiplicativeOperator), "_", "rollExpression"], "postprocess": d => operator(d, 'multiply')},
{"name": "multiplicativeExpression", "symbols": ["rollExpression"], "postprocess": id},
{"name": "rollExpression", "symbols": ["rollExpression", "_", (lexer.has("diceOperator") ? {type: "diceOperator"} : diceOperator), "_", "exponentExpression"], "postprocess": d => node.roll.create({left: d[0], right: d[4]})},
{"name": "rollExpression", "symbols": ["singleRollExpression"], "postprocess": id},
{"name": "singleRollExpression", "symbols": [{"literal":"d"}, "_", "singleRollExpression"], "postprocess": d => node.roll.create({left: node.constant.create({value: 1}), right: d[2]})},
{"name": "singleRollExpression", "symbols": ["exponentExpression"], "postprocess": id},
{"name": "exponentExpression", "symbols": ["callExpression", "_", (lexer.has("exponentOperator") ? {type: "exponentOperator"} : exponentOperator), "_", "exponentExpression"], "postprocess": d => operator(d, 'exponent')},
{"name": "exponentExpression", "symbols": ["unaryExpression"], "postprocess": id},
{"name": "unaryExpression", "symbols": [(lexer.has("additiveOperator") ? {type: "additiveOperator"} : additiveOperator), "_", "unaryExpression"], "postprocess": d => node.unaryOperator.create({operator: d[0].value, right: d[2]})},
{"name": "unaryExpression", "symbols": ["notExpression"], "postprocess": id},
{"name": "notExpression", "symbols": [(lexer.has("notOperator") ? {type: "notOperator"} : notOperator), "_", "notExpression"], "postprocess": d => node.not.create({right: d[2]})},
{"name": "notExpression", "symbols": ["callExpression"], "postprocess": id},
{"name": "callExpression", "symbols": ["name", "_", "arguments"], "postprocess":
d => node.call.create({functionName: d[0].name, args: d[2]})
},
{"name": "callExpression", "symbols": ["indexExpression"], "postprocess": id},
{"name": "arguments$subexpression$1", "symbols": ["expression"], "postprocess": d => d[0]},
{"name": "arguments$ebnf$1", "symbols": []},
{"name": "arguments$ebnf$1$subexpression$1", "symbols": ["_", (lexer.has("separator") ? {type: "separator"} : separator), "_", "expression"], "postprocess": d => d[3]},
{"name": "arguments$ebnf$1", "symbols": ["arguments$ebnf$1", "arguments$ebnf$1$subexpression$1"], "postprocess": function arrpush(d) {return d[0].concat([d[1]]);}},
{"name": "arguments", "symbols": [{"literal":"("}, "_", "arguments$subexpression$1", "arguments$ebnf$1", "_", {"literal":")"}], "postprocess":
d => [d[2], ...d[3]]
},
{"name": "arguments", "symbols": [{"literal":"("}, "_", {"literal":")"}], "postprocess": d => []},
{"name": "indexExpression", "symbols": ["indexExpression", {"literal":"["}, "_", "expression", "_", {"literal":"]"}], "postprocess": d => node.index.create({array: d[0], index: d[3]})},
{"name": "indexExpression", "symbols": ["arrayExpression"], "postprocess": id},
{"name": "arrayExpression$subexpression$1", "symbols": ["expression"], "postprocess": d => d[0]},
{"name": "arrayExpression$ebnf$1", "symbols": []},
{"name": "arrayExpression$ebnf$1$subexpression$1", "symbols": ["_", (lexer.has("separator") ? {type: "separator"} : separator), "_", "expression"], "postprocess": d => d[3]},
{"name": "arrayExpression$ebnf$1", "symbols": ["arrayExpression$ebnf$1", "arrayExpression$ebnf$1$subexpression$1"], "postprocess": function arrpush(d) {return d[0].concat([d[1]]);}},
{"name": "arrayExpression", "symbols": [{"literal":"["}, "_", "arrayExpression$subexpression$1", "arrayExpression$ebnf$1", "_", {"literal":"]"}], "postprocess":
d => node.array.create({ values: [d[2], ...d[3]] })
},
{"name": "arrayExpression", "symbols": [{"literal":"["}, "_", {"literal":"]"}], "postprocess": d => node.array.create({ values: [] })},
{"name": "arrayExpression", "symbols": ["parenthesizedExpression"], "postprocess": id},
{"name": "parenthesizedExpression", "symbols": [{"literal":"("}, "_", "expression", "_", {"literal":")"}], "postprocess": d => node.parenthesis.create({content: d[2]})},
{"name": "parenthesizedExpression", "symbols": ["accessorExpression"], "postprocess": id},
{"name": "accessorExpression$subexpression$1", "symbols": [(lexer.has("name") ? {type: "name"} : name)], "postprocess": d => d[0].value},
{"name": "accessorExpression$ebnf$1$subexpression$1", "symbols": [{"literal":"."}, "keyExpression"], "postprocess": d => d[1]},
{"name": "accessorExpression$ebnf$1", "symbols": ["accessorExpression$ebnf$1$subexpression$1"]},
{"name": "accessorExpression$ebnf$1$subexpression$2", "symbols": [{"literal":"."}, "keyExpression"], "postprocess": d => d[1]},
{"name": "accessorExpression$ebnf$1", "symbols": ["accessorExpression$ebnf$1", "accessorExpression$ebnf$1$subexpression$2"], "postprocess": function arrpush(d) {return d[0].concat([d[1]]);}},
{"name": "accessorExpression", "symbols": ["accessorExpression$subexpression$1", "accessorExpression$ebnf$1"], "postprocess":
d=> node.accessor.create({name: d[0], path: d[1]})
},
{"name": "accessorExpression", "symbols": ["valueExpression"], "postprocess": id},
{"name": "keyExpression", "symbols": ["name"], "postprocess": d => d[0].name},
{"name": "keyExpression", "symbols": ["number"], "postprocess": d => d[0].value},
{"name": "valueExpression", "symbols": ["name"], "postprocess": id},
{"name": "valueExpression", "symbols": ["number"], "postprocess": id},
{"name": "valueExpression", "symbols": ["string"], "postprocess": id},
{"name": "valueExpression", "symbols": ["boolean"], "postprocess": id},
{"name": "number", "symbols": [(lexer.has("number") ? {type: "number"} : number)], "postprocess": d => node.constant.create({value: +d[0].value})},
{"name": "name", "symbols": [(lexer.has("name") ? {type: "name"} : name)], "postprocess": d => node.accessor.create({name: d[0].value})},
{"name": "string", "symbols": [(lexer.has("string") ? {type: "string"} : string)], "postprocess": d => node.constant.create({value: d[0].value})},
{"name": "boolean", "symbols": [{"literal":"true"}], "postprocess": d => node.constant.create({value: true})},
{"name": "boolean", "symbols": [{"literal":"false"}], "postprocess": d => node.constant.create({value: false})},
{"name": "_", "symbols": []},
{"name": "_", "symbols": [(lexer.has("space") ? {type: "space"} : space)], "postprocess": nuller}
{ "name": "spacedExpression", "symbols": ["_", "expression", "_"], "postprocess": d => d[1] },
{ "name": "expression", "symbols": ["ifStatement"], "postprocess": id },
{
"name": "ifStatement", "symbols": ["orExpression", "_", (lexer.has("ifOperator") ? { type: "ifOperator" } : ifOperator), "_", "orExpression", "_", (lexer.has("elseOperator") ? { type: "elseOperator" } : elseOperator), "_", "ifStatement"], "postprocess":
d => node.if.create({ condition: d[0], consequent: d[4], alternative: d[8] })
},
{ "name": "ifStatement", "symbols": ["orExpression"], "postprocess": id },
{ "name": "orExpression", "symbols": ["orExpression", "_", (lexer.has("orOperator") ? { type: "orOperator" } : orOperator), "_", "andExpression"], "postprocess": d => operator(d, 'or') },
{ "name": "orExpression", "symbols": ["andExpression"], "postprocess": id },
{ "name": "andExpression", "symbols": ["andExpression", "_", (lexer.has("andOperator") ? { type: "andOperator" } : andOperator), "_", "equalityExpression"], "postprocess": d => operator(d, 'and') },
{ "name": "andExpression", "symbols": ["equalityExpression"], "postprocess": id },
{ "name": "equalityExpression", "symbols": ["equalityExpression", "_", (lexer.has("equalityOperator") ? { type: "equalityOperator" } : equalityOperator), "_", "relationalExpression"], "postprocess": d => operator(d, 'equality') },
{ "name": "equalityExpression", "symbols": ["relationalExpression"], "postprocess": id },
{ "name": "relationalExpression", "symbols": ["relationalExpression", "_", (lexer.has("relationalOperator") ? { type: "relationalOperator" } : relationalOperator), "_", "additiveExpression"], "postprocess": d => operator(d, 'relation') },
{ "name": "relationalExpression", "symbols": ["additiveExpression"], "postprocess": id },
{ "name": "additiveExpression", "symbols": ["additiveExpression", "_", (lexer.has("additiveOperator") ? { type: "additiveOperator" } : additiveOperator), "_", "remainderExpression"], "postprocess": d => operator(d, 'add') },
{ "name": "additiveExpression", "symbols": ["remainderExpression"], "postprocess": id },
{ "name": "remainderExpression", "symbols": ["remainderExpression", "_", (lexer.has("moduloOperator") ? { type: "moduloOperator" } : moduloOperator), "_", "multiplicativeExpression"], "postprocess": d => operator(d, 'remainder') },
{ "name": "remainderExpression", "symbols": ["multiplicativeExpression"], "postprocess": id },
{ "name": "multiplicativeExpression", "symbols": ["multiplicativeExpression", "_", (lexer.has("multiplicativeOperator") ? { type: "multiplicativeOperator" } : multiplicativeOperator), "_", "rollExpression"], "postprocess": d => operator(d, 'multiply') },
{ "name": "multiplicativeExpression", "symbols": ["rollExpression"], "postprocess": id },
{ "name": "rollExpression", "symbols": ["rollExpression", "_", (lexer.has("diceOperator") ? { type: "diceOperator" } : diceOperator), "_", "exponentExpression"], "postprocess": d => node.roll.create({ left: d[0], right: d[4] }) },
{ "name": "rollExpression", "symbols": ["singleRollExpression"], "postprocess": id },
{ "name": "singleRollExpression", "symbols": [{ "literal": "d" }, "_", "singleRollExpression"], "postprocess": d => node.roll.create({ left: node.constant.create({ value: 1 }), right: d[2] }) },
{ "name": "singleRollExpression", "symbols": ["exponentExpression"], "postprocess": id },
{ "name": "exponentExpression", "symbols": ["callExpression", "_", (lexer.has("exponentOperator") ? { type: "exponentOperator" } : exponentOperator), "_", "exponentExpression"], "postprocess": d => operator(d, 'exponent') },
{ "name": "exponentExpression", "symbols": ["unaryExpression"], "postprocess": id },
{ "name": "unaryExpression", "symbols": [(lexer.has("additiveOperator") ? { type: "additiveOperator" } : additiveOperator), "_", "unaryExpression"], "postprocess": d => node.unaryOperator.create({ operator: d[0].value, right: d[2] }) },
{ "name": "unaryExpression", "symbols": ["notExpression"], "postprocess": id },
{ "name": "notExpression", "symbols": [(lexer.has("notOperator") ? { type: "notOperator" } : notOperator), "_", "notExpression"], "postprocess": d => node.not.create({ right: d[2] }) },
{ "name": "notExpression", "symbols": ["callExpression"], "postprocess": id },
{
"name": "callExpression", "symbols": ["name", "_", "arguments"], "postprocess":
d => node.call.create({ functionName: d[0].name, args: d[2] })
},
{ "name": "callExpression", "symbols": ["indexExpression"], "postprocess": id },
{ "name": "arguments$subexpression$1", "symbols": ["expression"], "postprocess": d => d[0] },
{ "name": "arguments$ebnf$1", "symbols": [] },
{ "name": "arguments$ebnf$1$subexpression$1", "symbols": ["_", (lexer.has("separator") ? { type: "separator" } : separator), "_", "expression"], "postprocess": d => d[3] },
{ "name": "arguments$ebnf$1", "symbols": ["arguments$ebnf$1", "arguments$ebnf$1$subexpression$1"], "postprocess": function arrpush(d) { return d[0].concat([d[1]]); } },
{
"name": "arguments", "symbols": [{ "literal": "(" }, "_", "arguments$subexpression$1", "arguments$ebnf$1", "_", { "literal": ")" }], "postprocess":
d => [d[2], ...d[3]]
},
{ "name": "arguments", "symbols": [{ "literal": "(" }, "_", { "literal": ")" }], "postprocess": d => [] },
{ "name": "indexExpression", "symbols": ["indexExpression", { "literal": "[" }, "_", "expression", "_", { "literal": "]" }], "postprocess": d => node.index.create({ array: d[0], index: d[3] }) },
{ "name": "indexExpression", "symbols": ["arrayExpression"], "postprocess": id },
{ "name": "arrayExpression$subexpression$1", "symbols": ["expression"], "postprocess": d => d[0] },
{ "name": "arrayExpression$ebnf$1", "symbols": [] },
{ "name": "arrayExpression$ebnf$1$subexpression$1", "symbols": ["_", (lexer.has("separator") ? { type: "separator" } : separator), "_", "expression"], "postprocess": d => d[3] },
{ "name": "arrayExpression$ebnf$1", "symbols": ["arrayExpression$ebnf$1", "arrayExpression$ebnf$1$subexpression$1"], "postprocess": function arrpush(d) { return d[0].concat([d[1]]); } },
{
"name": "arrayExpression", "symbols": [{ "literal": "[" }, "_", "arrayExpression$subexpression$1", "arrayExpression$ebnf$1", "_", { "literal": "]" }], "postprocess":
d => node.array.create({ values: [d[2], ...d[3]] })
},
{ "name": "arrayExpression", "symbols": [{ "literal": "[" }, "_", { "literal": "]" }], "postprocess": d => node.array.create({ values: [] }) },
{ "name": "arrayExpression", "symbols": ["parenthesizedExpression"], "postprocess": id },
{ "name": "parenthesizedExpression", "symbols": [{ "literal": "(" }, "_", "expression", "_", { "literal": ")" }], "postprocess": d => node.parenthesis.create({ content: d[2] }) },
{ "name": "parenthesizedExpression", "symbols": ["accessorExpression"], "postprocess": id },
{ "name": "accessorExpression$subexpression$1", "symbols": [(lexer.has("name") ? { type: "name" } : name)], "postprocess": d => d[0].value },
{ "name": "accessorExpression$ebnf$1$subexpression$1", "symbols": [{ "literal": "." }, "keyExpression"], "postprocess": d => d[1] },
{ "name": "accessorExpression$ebnf$1", "symbols": ["accessorExpression$ebnf$1$subexpression$1"] },
{ "name": "accessorExpression$ebnf$1$subexpression$2", "symbols": [{ "literal": "." }, "keyExpression"], "postprocess": d => d[1] },
{ "name": "accessorExpression$ebnf$1", "symbols": ["accessorExpression$ebnf$1", "accessorExpression$ebnf$1$subexpression$2"], "postprocess": function arrpush(d) { return d[0].concat([d[1]]); } },
{
"name": "accessorExpression", "symbols": ["accessorExpression$subexpression$1", "accessorExpression$ebnf$1"], "postprocess":
d => node.accessor.create({ name: d[0], path: d[1] })
},
{ "name": "accessorExpression", "symbols": ["valueExpression"], "postprocess": id },
{ "name": "keyExpression", "symbols": ["name"], "postprocess": d => d[0].name },
{ "name": "keyExpression", "symbols": ["number"], "postprocess": d => d[0].value },
{ "name": "valueExpression", "symbols": ["name"], "postprocess": id },
{ "name": "valueExpression", "symbols": ["number"], "postprocess": id },
{ "name": "valueExpression", "symbols": ["string"], "postprocess": id },
{ "name": "valueExpression", "symbols": ["boolean"], "postprocess": id },
{ "name": "number", "symbols": [(lexer.has("number") ? { type: "number" } : number)], "postprocess": d => node.constant.create({ value: +d[0].value }) },
{ "name": "name", "symbols": [(lexer.has("name") ? { type: "name" } : name)], "postprocess": d => node.accessor.create({ name: d[0].value }) },
{ "name": "string", "symbols": [(lexer.has("string") ? { type: "string" } : string)], "postprocess": d => node.constant.create({ value: d[0].value }) },
{ "name": "boolean", "symbols": [{ "literal": "true" }], "postprocess": d => node.constant.create({ value: true }) },
{ "name": "boolean", "symbols": [{ "literal": "false" }], "postprocess": d => node.constant.create({ value: false }) },
{ "name": "_", "symbols": [] },
{ "name": "_", "symbols": [(lexer.has("space") ? { type: "space" } : space)], "postprocess": nuller }
];
let ParserStart = "spacedExpression";
export default { Lexer, ParserRules, ParserStart };

2
app/imports/parser/grammar.ne
View File

@@ -1,6 +1,6 @@
@preprocessor esmodule
@{%
import node from './parseTree/_index.js';
import node from './parseTree/_index';
import moo from 'moo';

26
app/imports/parser/parseTree/_index.js
View File

@@ -1,16 +1,16 @@
import accessor from './accessor.js';
import array from './array.js';
import call from './call.js';
import constant from './constant.js';
import error from './error.js';
import ifNode from './if.js';
import index from './index.js';
import not from './not.js';
import operator from './operator.js';
import parenthesis from './parenthesis.js';
import roll from './roll.js';
import rollArray from './rollArray.js';
import unaryOperator from './unaryOperator.js';
import accessor from './accessor';
import array from './array';
import call from './call';
import constant from './constant';
import error from './error';
import ifNode from './if';
import index from './index';
import not from './not';
import operator from './operator';
import parenthesis from './parenthesis';
import roll from './roll';
import rollArray from './rollArray';
import unaryOperator from './unaryOperator';
export default Object.freeze({
accessor,

11
app/imports/parser/parseTree/accessor.js
View File

@@ -1,6 +1,6 @@
import constant from './constant.js';
import array from './array.js';
import resolve from '../resolve.js';
import constant from './constant';
import array from './array';
import resolve from '../resolve';
import { getFromScope } from '/imports/api/creature/creatures/CreatureVariables';
const accessor = {
@@ -39,10 +39,7 @@ const accessor = {
// Return a parse node based on the constant type returned
if (valueType === 'string' || valueType === 'number' || valueType === 'boolean') {
return {
result: constant.create({
value,
valueType
}),
result: constant.create({ value }),
context,
};
}

4
app/imports/parser/parseTree/array.js
View File

@@ -1,5 +1,5 @@
import resolve, { toString, traverse, map } from '../resolve.js';
import constant from './constant.js';
import resolve, { toString, traverse, map } from '../resolve';
import constant from './constant';
const array = {
create({ values }) {

8
app/imports/parser/parseTree/call.js
View File

@@ -1,7 +1,7 @@
import error from './error.js';
import constant from './constant.js';
import functions from '/imports/parser/functions.js';
import resolve, { toString, traverse, map } from '../resolve.js';
import error from './error';
import constant from './constant';
import functions from '/imports/parser/functions';
import resolve, { toString, traverse, map } from '../resolve';
const call = {
create({ functionName, args }) {

20
app/imports/parser/parseTree/not.js
View File

@@ -1,16 +1,16 @@
import resolve, { toString, traverse, map } from '../resolve.js';
import constant from './constant.js';
import resolve, { toString, traverse, map } from '../resolve';
import constant from './constant';
const not = {
create({right}) {
create({ right }) {
return {
parseType: 'not',
right,
}
},
resolve(fn, node, scope, context){
const {result: right} = resolve(fn, node.right, scope, context);
if (right.parseType !== 'constant'){
resolve(fn, node, scope, context) {
const { result: right } = resolve(fn, node.right, scope, context);
if (right.parseType !== 'constant') {
return {
result: not.create({
right: right,
@@ -25,16 +25,16 @@ const not = {
context,
};
},
toString(node){
toString(node) {
return `!${toString(node.right)}`;
},
traverse(node, fn){
traverse(node, fn) {
fn(node);
traverse(node.right, fn);
},
map(node, fn){
map(node, fn) {
const resultingNode = fn(node);
if (resultingNode === node){
if (resultingNode === node) {
node.right = map(node.right, fn);
}
return resultingNode;

7
app/imports/parser/parseTree/operator.js
View File

@@ -1,18 +1,17 @@
import resolve, { toString, traverse, map } from '../resolve.js';
import constant from './constant.js';
import resolve, { toString, traverse, map } from '../resolve';
import constant from './constant';
// Which operators can be considered commutative by the parser
// i.e. 1 + 2 + 3 === 2 + 3 + 1
const commutativeOperators = ['+', '*']
const operator = {
create({ left, right, operator, fn }) {
create({ left, right, operator }) {
return {
parseType: 'operator',
left,
right,
operator,
fn
};
},
resolve(fn, node, scope, context) {

22
app/imports/parser/parseTree/parenthesis.js
View File

@@ -1,37 +1,37 @@
import resolve, { toString, traverse, map } from '../resolve.js';
import resolve, { toString, traverse, map } from '../resolve';
const parenthesis = {
create({content}) {
create({ content }) {
return {
parseType: 'parenthesis',
content,
};
},
resolve(fn, node, scope, context){
const {result: content} = resolve(fn, node.content, scope, context);
resolve(fn, node, scope, context) {
const { result: content } = resolve(fn, node.content, scope, context);
if (
fn === 'reduce' ||
content.parseType === 'constant' ||
content.parseType === 'error'
){
return {result: content, context};
) {
return { result: content, context };
} else {
return {
result: parenthesis.create({content}),
result: parenthesis.create({ content }),
context
};
}
},
toString(node){
toString(node) {
return `(${toString(node.content)})`;
},
traverse(node, fn){
traverse(node, fn) {
fn(node);
traverse(node.content, fn);
},
map(node, fn){
map(node, fn) {
const resultingNode = fn(node);
if (resultingNode === node){
if (resultingNode === node) {
node.content = map(node.content, fn);
}
return resultingNode;

10
app/imports/parser/parseTree/roll.js
View File

@@ -1,8 +1,8 @@
import resolve, { toString, traverse, map } from '../resolve.js';
import error from './error.js';
import rollArray from './rollArray.js';
import rollDice from '/imports/parser/rollDice.js';
import STORAGE_LIMITS from '/imports/constants/STORAGE_LIMITS.js';
import resolve, { toString, traverse, map } from '../resolve';
import error from './error';
import rollArray from './rollArray';
import rollDice from '/imports/parser/rollDice';
import STORAGE_LIMITS from '/imports/constants/STORAGE_LIMITS';
const rollNode = {
create({ left, right }) {

2
app/imports/parser/parseTree/rollArray.js
View File

@@ -1,4 +1,4 @@
import constant from './constant.js';
import constant from './constant';
const rollArray = {
create({ values, diceSize, diceNum }) {

22
app/imports/parser/parseTree/unaryOperator.js
View File

@@ -1,17 +1,17 @@
import resolve, { toString, traverse, map } from '../resolve.js';
import constant from './constant.js';
import resolve, { toString, traverse, map } from '../resolve';
import constant from './constant';
const unaryOperator = {
create({operator, right}) {
create({ operator, right }) {
return {
parseType: 'unaryOperator',
operator,
right,
};
},
resolve(fn, node, scope, context){
const {result: rightNode} = resolve(fn, node.right, scope, context);
if (rightNode.valueType !== 'number'){
resolve(fn, node, scope, context) {
const { result: rightNode } = resolve(fn, node.right, scope, context);
if (rightNode.valueType !== 'number') {
return {
result: unaryOperator.create({
operator: node.operator,
@@ -22,7 +22,7 @@ const unaryOperator = {
}
let right = rightNode.value;
let result;
switch(node.operator){
switch (node.operator) {
case '-': result = -right; break;
case '+': result = +right; break;
}
@@ -34,16 +34,16 @@ const unaryOperator = {
context,
};
},
toString(node){
toString(node) {
return `${node.operator}${toString(node.right)}`;
},
traverse(node, fn){
traverse(node, fn) {
fn(node);
traverse(node.right, fn);
},
map(node, fn){
map(node, fn) {
const resultingNode = fn(node);
if (resultingNode === node){
if (resultingNode === node) {
node.right = map(node.right, fn);
}
return resultingNode;

14
app/imports/parser/parser.js
View File

@@ -1,28 +1,28 @@
import grammar from '/imports/parser/grammar.js';
import grammar from '/imports/parser/grammar';
import nearley from 'nearley';
const nearleyGrammar = nearley.Grammar.fromCompiled(grammar);
export default function parser(){
export default function parser() {
return new nearley.Parser(nearleyGrammar);
}
export function parse(string){
export function parse(string) {
let parser = new nearley.Parser(nearleyGrammar);
parser.feed(string);
let results = parser.results;
if (results.length === 1){
if (results.length === 1) {
return results[0];
} else if (results.length === 0){
} else if (results.length === 0) {
// Valid parsing up until now, but need more
throw new EndOfInputError('Unexpected end of input');
} else {
console.warn('Grammar is ambiguous!', {string, results});
console.warn('Grammar is ambiguous!', { string, results });
return results[0];
}
}
export function prettifyParseError(e){
export function prettifyParseError(e) {
if (e.message) e = e.message
return e.toString().split('.')[0];
}

2
app/imports/parser/resolve.js
View File

@@ -1,4 +1,4 @@
import nodeTypeIndex from './parseTree/_index.js';
import nodeTypeIndex from './parseTree/_index';
// Takes a parse ndoe and computes it to a set detail level
// returns {result, context}