145 lines
4.4 KiB
TypeScript
145 lines
4.4 KiB
TypeScript
import * as fs from 'node:fs';
|
|
import * as path from 'node:path';
|
|
|
|
// Constants
|
|
export const INDENT = ' ';
|
|
export const POINTER_SIZE = 4;
|
|
export const RTTI_SIZE = POINTER_SIZE;
|
|
export const EXTENSION = '.def';
|
|
export const STRUCTURE_FILES: Record<string, string> = {};
|
|
export const COMMENT = '//';
|
|
export const INTERNAL = '__';
|
|
export const LEAN_HEADER_GUARD = '#ifndef LEAN_SYMBOLS_HEADER\n';
|
|
// Read Definition File
|
|
export function readDefinition(name: string) {
|
|
if (!STRUCTURE_FILES[name]) {
|
|
throw new Error(`Missing Definition File: ${name}${EXTENSION}`);
|
|
}
|
|
return fs.readFileSync(STRUCTURE_FILES[name], {encoding: 'utf8'});
|
|
}
|
|
// Error Handling
|
|
export function extendErrorMessage(e: unknown, message: string) {
|
|
let extra: string | null = null;
|
|
if (typeof e === 'string') {
|
|
extra = e;
|
|
} else if (e instanceof Error) {
|
|
extra = e.message;
|
|
}
|
|
if (extra) {
|
|
message += ': ' + extra;
|
|
}
|
|
return message;
|
|
}
|
|
export function syntaxError(message?: string): never {
|
|
throw new Error(extendErrorMessage(message, 'Syntax Error'));
|
|
}
|
|
// Convert 'int x' Into {type: 'int', name: 'x'}
|
|
const POINTER_TOKENS = ['*', '&'];
|
|
export function parseTypeAndName(piece: string) {
|
|
// Split On Last Space
|
|
const index = piece.lastIndexOf(' ');
|
|
if (index === -1) {
|
|
syntaxError('Unable To Find Name/Type Divider');
|
|
}
|
|
let name = piece.substring(index + 1);
|
|
let type = piece.substring(0, index);
|
|
// Move Asterisks From Name To Type
|
|
while (POINTER_TOKENS.some(x => name.startsWith(x))) {
|
|
const x = name.substring(0, 1);
|
|
name = name.substring(1);
|
|
if (!POINTER_TOKENS.some(x => type.endsWith(x))) {
|
|
type += ' ';
|
|
}
|
|
type += x;
|
|
}
|
|
// Return
|
|
return {type, name};
|
|
}
|
|
// Convert To Uppercase-Snake-Case
|
|
export function toUpperSnakeCase(str: string) {
|
|
let wasUpper = false;
|
|
let nextIsUpper = false;
|
|
let out = '';
|
|
for (let i = 0; i < str.length; i++) {
|
|
let character = str.charAt(i);
|
|
if (character === '_') {
|
|
wasUpper = false;
|
|
nextIsUpper = true;
|
|
continue;
|
|
}
|
|
const isUpper = character === character.toUpperCase() || nextIsUpper;
|
|
nextIsUpper = false;
|
|
character = character.toUpperCase();
|
|
if (isUpper && i > 0 && !wasUpper) {
|
|
out += '_';
|
|
}
|
|
out += character;
|
|
wasUpper = isUpper;
|
|
}
|
|
return out;
|
|
}
|
|
// Convert 'int' To 'int ' But Leave 'int *' As Is
|
|
export function formatType(type: string) {
|
|
if (!POINTER_TOKENS.some(x => type.endsWith(x))) {
|
|
type += ' ';
|
|
}
|
|
return type;
|
|
}
|
|
// Convert Number To Hexadecimal
|
|
export function toHex(x: number) {
|
|
return '0x' + x.toString(16);
|
|
}
|
|
// Generate C++ Size Assertion
|
|
export function assertSize(name: string, size: number) {
|
|
return `static_assert(sizeof(${name}) == ${toHex(size)}, "Invalid Size");\n`;
|
|
}
|
|
// Parse Integer With Error Checking
|
|
export function safeParseInt(str: string) {
|
|
const x = parseInt(str);
|
|
if (isNaN(x)) {
|
|
throw new Error('Invalid Integer: ' + str);
|
|
}
|
|
return x;
|
|
}
|
|
// Generate "Self" Argument For Functions
|
|
export function getSelfArg(type: string) {
|
|
return `${type} *self`;
|
|
}
|
|
// Prepend Argument To Function
|
|
export function prependArg(args: string, arg: string) {
|
|
if (args !== '()') {
|
|
arg += ', ';
|
|
}
|
|
return '(' + arg + args.substring(1);
|
|
}
|
|
// Get Data Directory
|
|
export function getDataDir() {
|
|
return path.join(__dirname, '..', 'data');
|
|
}
|
|
// Format File From Data Directory
|
|
export function formatFile(file: string, options: Record<string, string>) {
|
|
// Include Other Files
|
|
const dataDir = getDataDir();
|
|
const otherFiles = fs.readdirSync(dataDir);
|
|
for (let otherFile of otherFiles) {
|
|
otherFile = path.join(dataDir, otherFile);
|
|
options[`include ${otherFile}`] = fs.readFileSync(otherFile, 'utf8');
|
|
}
|
|
// Format
|
|
file = path.join(dataDir, file);
|
|
let data = fs.readFileSync(file, 'utf8');
|
|
for (const key in options) {
|
|
const value = options[key];
|
|
if (value) {
|
|
data = data.replace(`{{ ${key} }}`, value);
|
|
}
|
|
}
|
|
return data.trim() + '\n';
|
|
}
|
|
// Generate Code That Will Disable C++ Construction
|
|
export function preventConstruction(self: string) {
|
|
let out = '';
|
|
out += `${INDENT}${INTERNAL}PREVENT_CONSTRUCTION(${self});\n`;
|
|
out += `${INDENT}${INTERNAL}PREVENT_COPY(${self});\n`;
|
|
return out;
|
|
} |