516 lines
14 KiB
TypeScript
516 lines
14 KiB
TypeScript
import { lezerToParseTree } from "$common/markdown_parser/parse_tree.ts";
|
|
import {
|
|
cleanTree,
|
|
type ParseTree,
|
|
} from "@silverbulletmd/silverbullet/lib/tree";
|
|
import { parser } from "./parse-lua.js";
|
|
import { styleTags } from "@lezer/highlight";
|
|
import type {
|
|
LuaAttName,
|
|
LuaBlock,
|
|
LuaExpression,
|
|
LuaFunctionBody,
|
|
LuaFunctionCallExpression,
|
|
LuaFunctionName,
|
|
LuaLValue,
|
|
LuaPrefixExpression,
|
|
LuaStatement,
|
|
LuaTableField,
|
|
} from "./ast.ts";
|
|
|
|
const luaStyleTags = styleTags({
|
|
// Identifier: t.variableName,
|
|
// TagIdentifier: t.variableName,
|
|
// GlobalIdentifier: t.variableName,
|
|
// String: t.string,
|
|
// Number: t.number,
|
|
// PageRef: ct.WikiLinkTag,
|
|
// BinExpression: t.operator,
|
|
// TernaryExpression: t.operator,
|
|
// Regex: t.regexp,
|
|
// "where limit select render Order OrderKW and or null as InKW NotKW BooleanKW each all":
|
|
// t.keyword,
|
|
});
|
|
|
|
export const highlightingQueryParser = parser.configure({
|
|
props: [
|
|
luaStyleTags,
|
|
],
|
|
});
|
|
|
|
function parseChunk(t: ParseTree): LuaBlock {
|
|
if (t.type !== "Chunk") {
|
|
throw new Error(`Expected Chunk, got ${t.type}`);
|
|
}
|
|
return parseBlock(t.children![0]);
|
|
}
|
|
|
|
function parseBlock(t: ParseTree): LuaBlock {
|
|
if (t.type !== "Block") {
|
|
throw new Error(`Expected Block, got ${t.type}`);
|
|
}
|
|
const statements = t.children!.map(parseStatement);
|
|
return { type: "Block", statements, from: t.from, to: t.to };
|
|
}
|
|
|
|
function parseStatement(t: ParseTree): LuaStatement {
|
|
switch (t.type) {
|
|
case "Block":
|
|
return parseChunk(t.children![0]);
|
|
case "Semicolon":
|
|
return { type: "Semicolon", from: t.from, to: t.to };
|
|
case "Label":
|
|
return {
|
|
type: "Label",
|
|
name: t.children![1].children![0].text!,
|
|
from: t.from,
|
|
to: t.to,
|
|
};
|
|
case "Break":
|
|
return { type: "Break", from: t.from, to: t.to };
|
|
case "Goto":
|
|
return {
|
|
type: "Goto",
|
|
name: t.children![1].children![0].text!,
|
|
from: t.from,
|
|
to: t.to,
|
|
};
|
|
case "Scope":
|
|
return parseBlock(t.children![1]);
|
|
case ";":
|
|
return { type: "Semicolon", from: t.from, to: t.to };
|
|
case "WhileStatement":
|
|
return {
|
|
type: "While",
|
|
condition: parseExpression(t.children![1]),
|
|
block: parseBlock(t.children![3]),
|
|
};
|
|
case "RepeatStatement":
|
|
return {
|
|
type: "Repeat",
|
|
block: parseBlock(t.children![1]),
|
|
condition: parseExpression(t.children![3]),
|
|
};
|
|
case "IfStatement": {
|
|
const conditions: {
|
|
condition: LuaExpression;
|
|
block: LuaBlock;
|
|
from?: number;
|
|
to?: number;
|
|
}[] = [];
|
|
let elseBlock: LuaBlock | undefined = undefined;
|
|
for (let i = 0; i < t.children!.length; i += 4) {
|
|
console.log("Looking at", t.children![i]);
|
|
const child = t.children![i];
|
|
if (
|
|
child.children![0].text === "if" ||
|
|
child.children![0].text === "elseif"
|
|
) {
|
|
conditions.push({
|
|
condition: parseExpression(t.children![i + 1]),
|
|
block: parseBlock(t.children![i + 3]),
|
|
from: child.from,
|
|
to: child.to,
|
|
});
|
|
} else if (child.children![0].text === "else") {
|
|
elseBlock = parseBlock(t.children![i + 1]);
|
|
} else if (child.children![0].text === "end") {
|
|
break;
|
|
} else {
|
|
throw new Error(
|
|
`Unknown if clause type: ${child.children![0].text}`,
|
|
);
|
|
}
|
|
}
|
|
return {
|
|
type: "If",
|
|
conditions,
|
|
elseBlock,
|
|
from: t.from,
|
|
to: t.to,
|
|
};
|
|
}
|
|
case "ForStatement":
|
|
if (t.children![1].type === "ForNumeric") {
|
|
const forNumeric = t.children![1];
|
|
return {
|
|
type: "For",
|
|
name: forNumeric.children![0].children![0].text!,
|
|
start: parseExpression(forNumeric.children![2]),
|
|
end: parseExpression(forNumeric.children![4]),
|
|
step: forNumeric.children![5]
|
|
? parseExpression(forNumeric.children![6])
|
|
: undefined,
|
|
block: parseBlock(t.children![3]),
|
|
from: t.from,
|
|
to: t.to,
|
|
};
|
|
} else {
|
|
const forGeneric = t.children![1];
|
|
return {
|
|
type: "ForIn",
|
|
names: parseNameList(forGeneric.children![0]),
|
|
expressions: parseExpList(forGeneric.children![2]),
|
|
block: parseBlock(t.children![3]),
|
|
from: t.from,
|
|
to: t.to,
|
|
};
|
|
}
|
|
case "Function":
|
|
return {
|
|
type: "Function",
|
|
name: parseFunctionName(t.children![1]),
|
|
body: parseFunctionBody(t.children![2]),
|
|
from: t.from,
|
|
to: t.to,
|
|
};
|
|
case "LocalFunction":
|
|
return {
|
|
type: "LocalFunction",
|
|
name: t.children![2].children![0].text!,
|
|
body: parseFunctionBody(t.children![3]),
|
|
};
|
|
case "FunctionCall":
|
|
return {
|
|
type: "FunctionCallStatement",
|
|
call: parseExpression(
|
|
{
|
|
type: "FunctionCall",
|
|
children: t.children!,
|
|
from: t.from,
|
|
to: t.to,
|
|
},
|
|
) as LuaFunctionCallExpression,
|
|
};
|
|
case "Assign":
|
|
return {
|
|
type: "Assignment",
|
|
variables: t.children![0].children!.filter((t) => t.type !== ",").map(
|
|
parseLValue,
|
|
),
|
|
expressions: parseExpList(t.children![2]),
|
|
from: t.from,
|
|
to: t.to,
|
|
};
|
|
case "Local":
|
|
return {
|
|
type: "Local",
|
|
names: parseAttNames(t.children![1]),
|
|
expressions: t.children![3] ? parseExpList(t.children![3]) : [],
|
|
from: t.from,
|
|
to: t.to,
|
|
};
|
|
case "ReturnStatement": {
|
|
const expressions = t.children![1] ? parseExpList(t.children![1]) : [];
|
|
return { type: "Return", expressions, from: t.from, to: t.to };
|
|
}
|
|
case "break":
|
|
return { type: "Break", from: t.from, to: t.to };
|
|
default:
|
|
console.error(t);
|
|
throw new Error(`Unknown statement type: ${t.children![0].text}`);
|
|
}
|
|
}
|
|
|
|
function parseAttNames(t: ParseTree): LuaAttName[] {
|
|
if (t.type !== "AttNameList") {
|
|
throw new Error(`Expected AttNameList, got ${t.type}`);
|
|
}
|
|
return t.children!.filter((t) => t.type !== ",").map(parseAttName);
|
|
}
|
|
|
|
function parseAttName(t: ParseTree): LuaAttName {
|
|
if (t.type !== "AttName") {
|
|
throw new Error(`Expected AttName, got ${t.type}`);
|
|
}
|
|
return {
|
|
type: "AttName",
|
|
name: t.children![0].children![0].text!,
|
|
attribute: t.children![1].children![1]
|
|
? t.children![1].children![1].children![0].text!
|
|
: undefined,
|
|
from: t.from,
|
|
to: t.to,
|
|
};
|
|
}
|
|
|
|
function parseLValue(t: ParseTree): LuaLValue {
|
|
switch (t.type) {
|
|
case "Name":
|
|
return {
|
|
type: "Variable",
|
|
name: t.children![0].text!,
|
|
from: t.from,
|
|
to: t.to,
|
|
};
|
|
case "Property":
|
|
return {
|
|
type: "PropertyAccess",
|
|
object: parsePrefixExpression(t.children![0]),
|
|
property: t.children![2].children![0].text!,
|
|
from: t.from,
|
|
to: t.to,
|
|
};
|
|
case "MemberExpression":
|
|
return {
|
|
type: "TableAccess",
|
|
object: parsePrefixExpression(t.children![0]),
|
|
key: parseExpression(t.children![2]),
|
|
from: t.from,
|
|
to: t.to,
|
|
};
|
|
default:
|
|
console.error(t);
|
|
throw new Error(`Unknown lvalue type: ${t.type}`);
|
|
}
|
|
}
|
|
|
|
function parseFunctionName(t: ParseTree): LuaFunctionName {
|
|
if (t.type !== "FuncName") {
|
|
throw new Error(`Expected FunctionName, got ${t.type}`);
|
|
}
|
|
const propNames: string[] = [];
|
|
let colonName: string | undefined = undefined;
|
|
for (let i = 0; i < t.children!.length; i += 2) {
|
|
const prop = t.children![i];
|
|
propNames.push(prop.children![0].text!);
|
|
if (t.children![i + 1] && t.children![i + 1].type === ":") {
|
|
colonName = t.children![i + 2].children![0].text!;
|
|
break;
|
|
}
|
|
}
|
|
return {
|
|
type: "FunctionName",
|
|
propNames,
|
|
colonName,
|
|
from: t.from,
|
|
to: t.to,
|
|
};
|
|
}
|
|
|
|
function parseNameList(t: ParseTree): string[] {
|
|
if (t.type !== "NameList") {
|
|
throw new Error(`Expected NameList, got ${t.type}`);
|
|
}
|
|
return t.children!.filter((t) => t.type === "Name").map((t) =>
|
|
t.children![0].text!
|
|
);
|
|
}
|
|
|
|
function parseExpList(t: ParseTree): LuaExpression[] {
|
|
if (t.type !== "ExpList") {
|
|
throw new Error(`Expected ExpList, got ${t.type}`);
|
|
}
|
|
return t.children!.filter((t) => t.type !== ",").map(parseExpression);
|
|
}
|
|
|
|
function parseExpression(t: ParseTree): LuaExpression {
|
|
switch (t.type) {
|
|
case "LiteralString": {
|
|
let cleanString = t.children![0].text!;
|
|
// Remove quotes etc
|
|
cleanString = cleanString.slice(1, -1);
|
|
return {
|
|
type: "String",
|
|
value: cleanString,
|
|
from: t.from,
|
|
to: t.to,
|
|
};
|
|
}
|
|
case "Number":
|
|
return {
|
|
type: "Number",
|
|
value: parseFloat(t.children![0].text!),
|
|
from: t.from,
|
|
to: t.to,
|
|
};
|
|
case "BinaryExpression":
|
|
return {
|
|
type: "Binary",
|
|
operator: t.children![1].children![0].text!,
|
|
left: parseExpression(t.children![0]),
|
|
right: parseExpression(t.children![2]),
|
|
from: t.from,
|
|
to: t.to,
|
|
};
|
|
case "UnaryExpression":
|
|
return {
|
|
type: "Unary",
|
|
operator: t.children![0].children![0].text!,
|
|
argument: parseExpression(t.children![1]),
|
|
from: t.from,
|
|
to: t.to,
|
|
};
|
|
case "Property":
|
|
return {
|
|
type: "PropertyAccess",
|
|
object: parsePrefixExpression(t.children![0]),
|
|
property: t.children![2].children![0].text!,
|
|
from: t.from,
|
|
to: t.to,
|
|
};
|
|
|
|
case "Parens":
|
|
return parseExpression(t.children![1]);
|
|
case "FunctionCall": {
|
|
if (t.children![1].type === ":") {
|
|
return {
|
|
type: "FunctionCall",
|
|
prefix: parsePrefixExpression(t.children![0]),
|
|
name: t.children![2].children![0].text!,
|
|
args: parseFunctionArgs(t.children!.slice(3)),
|
|
from: t.from,
|
|
to: t.to,
|
|
};
|
|
}
|
|
return {
|
|
type: "FunctionCall",
|
|
prefix: parsePrefixExpression(t.children![0]),
|
|
args: parseFunctionArgs(t.children!.slice(1)),
|
|
from: t.from,
|
|
to: t.to,
|
|
};
|
|
}
|
|
case "FunctionDef": {
|
|
const body = parseFunctionBody(t.children![1]);
|
|
return {
|
|
type: "FunctionDefinition",
|
|
body,
|
|
from: t.from,
|
|
to: t.to,
|
|
};
|
|
}
|
|
case "Name":
|
|
return {
|
|
type: "Variable",
|
|
name: t.children![0].text!,
|
|
from: t.from,
|
|
to: t.to,
|
|
};
|
|
case "Ellipsis":
|
|
return { type: "Variable", name: "...", from: t.from, to: t.to };
|
|
case "true":
|
|
return { type: "Boolean", value: true, from: t.from, to: t.to };
|
|
case "false":
|
|
return { type: "Boolean", value: false, from: t.from, to: t.to };
|
|
case "TableConstructor":
|
|
return {
|
|
type: "TableConstructor",
|
|
fields: t.children!.slice(1, -1).filter((t) =>
|
|
["FieldExp", "FieldProp", "FieldDynamic"].includes(t.type!)
|
|
).map(parseTableField),
|
|
from: t.from,
|
|
to: t.to,
|
|
};
|
|
case "nil":
|
|
return { type: "Nil", from: t.from, to: t.to };
|
|
default:
|
|
console.error(t);
|
|
throw new Error(`Unknown expression type: ${t.type}`);
|
|
}
|
|
}
|
|
|
|
function parseFunctionArgs(ts: ParseTree[]): LuaExpression[] {
|
|
console.log("Parsing function args", JSON.stringify(ts, null, 2));
|
|
return ts.filter((t) => ![",", "(", ")"].includes(t.type!)).map(
|
|
parseExpression,
|
|
);
|
|
}
|
|
|
|
function parseFunctionBody(t: ParseTree): LuaFunctionBody {
|
|
if (t.type !== "FuncBody") {
|
|
throw new Error(`Expected FunctionBody, got ${t.type}`);
|
|
}
|
|
return {
|
|
type: "FunctionBody",
|
|
parameters: t.children![1].children!.filter((t) =>
|
|
["Name", "Ellipsis"].includes(t.type!)
|
|
)
|
|
.map((t) => t.children![0].text!),
|
|
block: parseBlock(t.children![3]),
|
|
from: t.from,
|
|
to: t.to,
|
|
};
|
|
}
|
|
|
|
function parsePrefixExpression(t: ParseTree): LuaPrefixExpression {
|
|
switch (t.type) {
|
|
case "Name":
|
|
return {
|
|
type: "Variable",
|
|
name: t.children![0].text!,
|
|
from: t.from,
|
|
to: t.to,
|
|
};
|
|
case "Property":
|
|
return {
|
|
type: "PropertyAccess",
|
|
object: parsePrefixExpression(t.children![0]),
|
|
property: t.children![2].children![0].text!,
|
|
from: t.from,
|
|
to: t.to,
|
|
};
|
|
case "MemberExpression":
|
|
return {
|
|
type: "TableAccess",
|
|
object: parsePrefixExpression(t.children![0]),
|
|
key: parseExpression(t.children![2]),
|
|
from: t.from,
|
|
to: t.to,
|
|
};
|
|
case "Parens":
|
|
return {
|
|
type: "Parenthesized",
|
|
expression: parseExpression(t.children![1]),
|
|
from: t.from,
|
|
to: t.to,
|
|
};
|
|
default:
|
|
console.error(t);
|
|
throw new Error(`Unknown prefix expression type: ${t.type}`);
|
|
}
|
|
}
|
|
|
|
function parseTableField(t: ParseTree): LuaTableField {
|
|
switch (t.type) {
|
|
case "FieldExp":
|
|
return {
|
|
type: "ExpressionField",
|
|
value: parseExpression(t.children![0]),
|
|
from: t.from,
|
|
to: t.to,
|
|
};
|
|
case "FieldProp":
|
|
return {
|
|
type: "PropField",
|
|
key: t.children![0].children![0].text!,
|
|
value: parseExpression(t.children![2]),
|
|
from: t.from,
|
|
to: t.to,
|
|
};
|
|
case "FieldDynamic":
|
|
return {
|
|
type: "DynamicField",
|
|
key: parseExpression(t.children![1]),
|
|
value: parseExpression(t.children![4]),
|
|
from: t.from,
|
|
to: t.to,
|
|
};
|
|
default:
|
|
console.error(t);
|
|
throw new Error(`Unknown table field type: ${t.type}`);
|
|
}
|
|
}
|
|
|
|
export function parse(s: string): LuaBlock {
|
|
const t = parseToCrudeAST(s);
|
|
console.log("Clean tree", JSON.stringify(t, null, 2));
|
|
const result = parseChunk(t);
|
|
console.log("Parsed AST", JSON.stringify(result, null, 2));
|
|
return result;
|
|
}
|
|
|
|
export function parseToCrudeAST(t: string): ParseTree {
|
|
return cleanTree(lezerToParseTree(t, parser.parse(t).topNode), true);
|
|
}
|