99 lines
3.0 KiB
TypeScript
99 lines
3.0 KiB
TypeScript
import error from '/imports/parser/parseTree/error';
|
|
import ParseNode from '/imports/parser/parseTree/ParseNode';
|
|
import toString from '/imports/parser/toString';
|
|
import { isFiniteNode } from '/imports/parser/parseTree/constant';
|
|
import ResolveFunction from '/imports/parser/types/ResolveFunction';
|
|
import TraverseFunction from '/imports/parser/types/TraverseFunction';
|
|
import MapFunction from '/imports/parser/types/MapFunction';
|
|
import ToStringFunction from '/imports/parser/types/ToStringFunction';
|
|
|
|
export type IndexNode = {
|
|
parseType: 'index';
|
|
array: ParseNode;
|
|
index: ParseNode;
|
|
}
|
|
|
|
type IndexFactory = {
|
|
create(node: Partial<IndexNode>): IndexNode;
|
|
resolve: ResolveFunction<IndexNode>;
|
|
toString: ToStringFunction<IndexNode>;
|
|
traverse: TraverseFunction<IndexNode>;
|
|
map: MapFunction<IndexNode>;
|
|
}
|
|
|
|
const indexNode: IndexFactory = {
|
|
create({ array, index }: { array: ParseNode, index: ParseNode }) {
|
|
return {
|
|
parseType: 'index',
|
|
array,
|
|
index,
|
|
}
|
|
},
|
|
async resolve(fn, node, scope, context, inputProvider, resolveOthers) {
|
|
const { result: index } = await resolveOthers(fn, node.index, scope, context, inputProvider);
|
|
const { result: array } = await resolveOthers(fn, node.array, scope, context, inputProvider);
|
|
|
|
if (
|
|
isFiniteNode(index) &&
|
|
Number.isInteger(index.value) &&
|
|
array.parseType === 'array'
|
|
) {
|
|
if (index.value < 1 || index.value > array.values.length) {
|
|
context.error(`Index of ${index.value} is out of range for an array` +
|
|
` of length ${array.values.length}`);
|
|
}
|
|
const selection = array.values[index.value - 1];
|
|
if (selection) {
|
|
return resolveOthers(fn, selection, scope, context, inputProvider);
|
|
}
|
|
} else if (fn === 'reduce') {
|
|
if (array.parseType !== 'array') {
|
|
const message = `Can not get the index of a non-array node: ${toString(node.array)} = ${toString(array)}`
|
|
context.error(message);
|
|
return {
|
|
result: error.create({
|
|
node,
|
|
error: message,
|
|
}),
|
|
context,
|
|
};
|
|
} else if (!isFiniteNode(index) || !Number.isInteger(index.value)) {
|
|
const message = `${toString(array)} is not an integer index of the array`
|
|
context.error(message);
|
|
return {
|
|
result: error.create({
|
|
node,
|
|
error: message,
|
|
}),
|
|
context,
|
|
};
|
|
}
|
|
}
|
|
return {
|
|
result: indexNode.create({
|
|
index,
|
|
array,
|
|
}),
|
|
context,
|
|
};
|
|
},
|
|
toString(node, stringOthers) {
|
|
return `${stringOthers(node.array)}[${stringOthers(node.index)}]`;
|
|
},
|
|
traverse(node, fn, traverseOthers) {
|
|
fn(node);
|
|
traverseOthers(node.array, fn);
|
|
traverseOthers(node.index, fn);
|
|
},
|
|
async map(node, fn, mapOthers) {
|
|
const resultingNode = await fn(node);
|
|
if (resultingNode === node) {
|
|
node.array = await mapOthers(node.array, fn);
|
|
node.index = await mapOthers(node.index, fn);
|
|
}
|
|
return resultingNode;
|
|
},
|
|
}
|
|
|
|
export default indexNode;
|