@nirguna/plugin-fasm 1.0.0

package/lib/convert-bios-read-sector-to-int-13/index.js

@@ -0,0 +1,80 @@
+import {operator, types} from 'putout';
+
+const {isArrayExpression} = types;
+const {extract} = operator;
+
+export const report = () => `Use '0x13' instead of 'bios.readSector()'`;
+
+export const match = () => ({
+    'bios.readSector()': (vars, path) => {
+        return path.parentPath.isExpressionStatement();
+    },
+});
+
+export const replace = () => ({
+    '__a = bios.readSector(__object)': ({__object}, path) => {
+        const {line} = path.node.loc.start;
+        const {
+            count = 1,
+            buffer = 0,
+            sector = 0,
+            track = 0,
+            disk = 0,
+            head = 0,
+        } = parseArgs(__object.properties);
+        
+        return `{
+            al = ${count};
+            bx = ${buffer};
+            cl = ${sector};
+            ch = ${track};
+            dl = ${disk};
+            dh = ${head}; 
+            ${createReadSector(line)}
+            mov(__a, ax);
+        }`;
+    },
+    '__a = bios.readSector()': (vars, path) => {
+        const {line} = path.node.loc.start;
+        
+        return `{
+            ${createReadSector(line)}
+            mov(__a, ax);
+        }`;
+    },
+    'bios.readSector()': (vars, path) => {
+        const {line} = path.node.loc.start;
+        return createReadSector(line);
+    },
+});
+
+function createReadSector(line) {
+    return `{
+        ah = 2;
+        int(0x13);
+        jnc(__nirguna_read_sector_ok_${line});
+        al = 1;
+        jmp(__nirguna_read_sector_end_${line});
+        __nirguna_read_sector_ok_${line}:
+        ax = 0
+        __nirguna_read_sector_end_${line}:
+        clc();
+    }`;
+}
+
+function parseArgs(properties) {
+    const result = {};
+    
+    for (const {key, value} of properties) {
+        const extracted = extract(value);
+        
+        if (isArrayExpression(value)) {
+            result[key.name] = `[${extracted}]`;
+            continue;
+        }
+        
+        result[key.name] = extracted;
+    }
+    
+    return result;
+}

package/lib/convert-bios-reboot-to-jmp-far/index.js

@@ -0,0 +1,5 @@
+export const report = () => `Use 'jmp far' instead of 'bios.reboot()'`;
+
+export const replace = () => ({
+    'bios.reboot()': `jmp.far('0xFFFF:0x0000')`,
+});

package/lib/convert-bios-scroll-to-int-10/index.js

@@ -0,0 +1,16 @@
+export const report = () => `Use '0x10' instead of 'bios.readChar()'`;
+
+export const match = () => ({
+    'bios.scroll()': (vars, path) => {
+        return path.parentPath.isExpressionStatement();
+    },
+});
+
+export const replace = () => ({
+    'bios.scroll()': `{
+        cx = 0; // от 00:00
+        ax = 0x601; // Прокрутка вверх на одну строку
+        dx = 0x184f; // 24:79 (весь экран)
+        int(0x10);
+    }`,
+});

package/lib/convert-const-to-equ/index.js

@@ -0,0 +1,15 @@
+import {types} from 'putout';
+
+const {isProgram} = types;
+
+export const report = () => `Use 'equ' instead of 'const'`;
+
+export const match = () => ({
+    'const __a = __b': (vars, path) => {
+        return isProgram(path.parentPath);
+    },
+});
+
+export const replace = () => ({
+    'const __a = __b': '__a.equ = __b;',
+});

package/lib/convert-dec-to-hex/index.js

@@ -0,0 +1,19 @@
+export const report = () => `Use hex index of dec`;
+
+export const filter = (path) => {
+    const {raw, value} = path.node;
+    
+    if (value < 10)
+        return false;
+    
+    return !raw?.startsWith('0x');
+};
+
+export const fix = (path) => {
+    const {value} = path.node;
+    path.node.raw = '0x' + value.toString(16);
+};
+
+export const include = () => [
+    'NumericLiteral',
+];

package/lib/convert-declaration-to-mov/index.js

@@ -0,0 +1,23 @@
+import {types} from 'putout';
+import {isRegister} from '@nirguna/operator-fasm/regs';
+
+const {isExportDeclaration} = types;
+
+export const report = () => `Use 'mov' instead of 'const'`;
+
+export const match = () => ({
+    'const __a = __b': ({__a}, path) => {
+        if (!isRegister(__a.name))
+            return false;
+        
+        return !isExportDeclaration(path.parentPath);
+    },
+    'let __a = __b': ({__a}) => {
+        return isRegister(__a.name);
+    },
+});
+
+export const replace = () => ({
+    'const __a = __b': 'mov(__a, __b)',
+    'let __a = __b': 'mov(__a, __b)',
+});

package/lib/convert-do-while-to-jnz/index.js

@@ -0,0 +1,155 @@
+import {
+    template,
+    types,
+    operator,
+} from 'putout';
+
+const {
+    insertAfter,
+    replaceWith,
+    compare,
+    extract,
+} = operator;
+
+const {
+    identifier,
+    expressionStatement,
+    isCallExpression,
+    labeledStatement,
+    isBooleanLiteral,
+} = types;
+
+const createStartLabel = (line) => `__nirguna_do_while_${line}`;
+const createConditionLabel = (line) => `__nirguna_do_while_condition_${line}`;
+
+export const report = () => `Use 'jnz' instead of 'do-while'`;
+
+export const match = () => ({
+    'do {__body} while (--__a)': ({__a}) => {
+        return /^(e?cx|cl)$/.test(__a.name);
+    },
+});
+
+export const replace = () => ({
+    'do {__body} while (--__a)': ({__body}, path) => {
+        const {line} = path.node.loc.start;
+        const startLabel = createStartLabel(line);
+        const loopExpression = template.ast(`loop(${startLabel})`);
+        const conditionLabel = createConditionLabel(line);
+        
+        let conditionExpression = expressionStatement(loopExpression);
+        const wasContinue = maybeReplaceContinueWithJmp(path, conditionLabel);
+        
+        if (wasContinue)
+            conditionExpression = labeledStatement(identifier(conditionLabel), conditionExpression);
+        
+        __body.body.push(conditionExpression);
+        maybeReplaceBreak(path, line);
+        
+        return `${startLabel}: __body`;
+    },
+    'do {__body} while (!__a)': ({__a, __body}, path) => {
+        const {line} = path.node.loc.start;
+        const startLabel = createStartLabel(line);
+        const conditionLabel = createConditionLabel(line);
+        const expression = isCallExpression(__a) ? __a : template.ast(`test(${__a.name}, ${__a.name})`);
+        
+        let conditionExpression = expressionStatement(expression);
+        const wasContinue = maybeReplaceContinueWithJmp(path, conditionLabel);
+        
+        if (wasContinue)
+            conditionExpression = labeledStatement(identifier(conditionLabel), conditionExpression);
+        
+        __body.body.push(conditionExpression);
+        __body.body.push(expressionStatement(template.ast(`jz(${startLabel})`)));
+        
+        return `${startLabel}: __body`;
+    },
+    'do {__body} while (__a)': ({__a, __body}, path) => {
+        const {line} = path.node.loc.start;
+        const startLabel = createStartLabel(line);
+        const conditionLabel = createConditionLabel(line);
+        const [one, two, jnz, test] = parseWhileArgs(__a);
+        const expression = isCallExpression(__a) ? __a : template.ast(`${test}(${one}, ${two})`);
+        
+        let conditionExpression = expressionStatement(expression);
+        const wasContinue = maybeReplaceContinueWithJmp(path, conditionLabel);
+        
+        if (wasContinue)
+            conditionExpression = labeledStatement(identifier(conditionLabel), conditionExpression);
+        
+        __body.body.push(conditionExpression);
+        __body.body.push(expressionStatement(template.ast(`${jnz}(${startLabel})`)));
+        
+        maybeReplaceBreak(path, line);
+        
+        return `${startLabel}: __body`;
+    },
+});
+
+const parseWhileArgs = (__a) => {
+    if (isBooleanLiteral(__a) && __a.value)
+        return [
+            'al',
+            'al',
+            'je',
+            'cmp',
+        ];
+    
+    if (isBooleanLiteral(__a) && !__a.value)
+        return [
+            'al',
+            'al',
+            'jne',
+            'cmp',
+        ];
+    
+    if (compare(__a, '__a === __b'))
+        return [
+            extract(__a.left),
+            extract(__a.right),
+            'jz',
+            'cmp',
+        ];
+    
+    return [
+        __a.name,
+        __a.name,
+        'jnz',
+        'test',
+    ];
+};
+
+function maybeReplaceBreak(path, line) {
+    let wasBreak = false;
+    const breakLabel = `__nirguna_do_while_break_${line}`;
+    
+    path.traverse({
+        BreakStatement(path) {
+            wasBreak = true;
+            path.replaceWithSourceString(`jmp(${breakLabel})`);
+        },
+    });
+    
+    if (wasBreak) {
+        const nextPath = path.getNextSibling();
+        const labeledNode = labeledStatement(identifier(breakLabel), nextPath.node || expressionStatement(template.ast('nop()')));
+        
+        if (nextPath.node)
+            replaceWith(nextPath, labeledNode);
+        else
+            insertAfter(path, labeledNode);
+    }
+}
+
+function maybeReplaceContinueWithJmp(path, startLabel) {
+    let was = false;
+    
+    path.traverse({
+        ContinueStatement(path) {
+            path.replaceWithSourceString(`jmp(${startLabel})`);
+            was = true;
+        },
+    });
+    return was;
+}

package/lib/convert-equ-call-to-member/index.js

@@ -0,0 +1,30 @@
+import {template, types} from 'putout';
+
+const {
+    isStringLiteral,
+    stringLiteral,
+} = types;
+
+export const report = () => `Use '__a.equ.__b' instead of equ(__a, __b)`;
+
+const createEqu = template('__a.equ[__b]', {
+    placeholderPattern: /__[a-z]/,
+});
+
+export const replace = () => ({
+    'equ(__a, __b)': ({__a, __b}) => {
+        return createEqu({
+            __a,
+            __b: maybeStringLiteral(__b),
+        });
+    },
+});
+
+function maybeStringLiteral(a) {
+    if (isStringLiteral(a))
+        return a;
+    
+    const hex = '0x' + Number(a.raw).toString(16);
+    
+    return stringLiteral(hex);
+}

package/lib/convert-function-to-label/index.js

@@ -0,0 +1,114 @@
+import {types, operator} from 'putout';
+
+const {compare} = operator;
+const {
+    isCallExpression,
+    isReturnStatement,
+    expressionStatement,
+    identifier,
+    arrayExpression,
+    callExpression,
+    isExportNamedDeclaration,
+    numericLiteral,
+} = types;
+
+export const report = () => `Use 'label' instead of 'function'`;
+
+export const filter = (path) => {
+    if (isExportNamedDeclaration(path.parentPath))
+        return false;
+    
+    if (path.node.params.length)
+        return false;
+    
+    const {returnType} = path.node;
+    
+    if (returnType && returnType.typeAnnotation.typeName.name !== 'iret')
+        return false;
+    
+    const last = path.node.body.body.at(-1);
+    
+    return !(isCallExpression(last) && last.callee.name === 'ret');
+};
+
+export const replace = () => ({
+    'async function __a<__type_params>(__args): __b {__body}': convertFnToLabel(),
+    'function __a<__type_params>(__args): __b {__body}': convertFnToLabel(),
+    'function __a(__args): __b {__body}': convertFnToLabel(),
+    'async function __a(__args): __b {__body}': convertFnToLabel(),
+    'async function __a<__type_params>(__args) {__body}': convertFnToLabel('ret'),
+    'function __a<__type_params>(__args) {__body}': convertFnToLabel('ret'),
+    'function __a(__args) {__body}': convertFnToLabel('ret'),
+    'async function __a(__args) {__body}': convertFnToLabel('ret'),
+});
+
+const convertFnToLabel = (ret) => ({__b, __type_params, __body}, path) => {
+    addStackOperations({
+        __type_params,
+        __body,
+    });
+    
+    if (__b)
+        path.traverse({
+            ReturnStatement(path) {
+                path.replaceWithSourceString('iret()');
+            },
+        });
+    
+    const last = __body.body.at(-1);
+    
+    if (!compare(last, 'ret()')) {
+        const iret = expressionStatement(maybeRet(ret, path) || callExpression(__b.typeName, []));
+        __body.body.push(iret);
+    }
+    
+    return '__a: __body';
+};
+
+const maybeRet = (name, path) => {
+    if (!name)
+        return false;
+    
+    const count = path.__nirguna_args_size;
+    const args = [];
+    
+    if (count)
+        args.push(numericLiteral(count));
+    
+    return callExpression(identifier(name), args);
+};
+
+function addStackOperations({__body, __type_params = []}) {
+    const args = [];
+    
+    for (const {name} of __type_params) {
+        args.push(name);
+    }
+    
+    if (!args.length)
+        return;
+    
+    const push = createStackOperation('push', args);
+    
+    const pop = createStackOperation('pop', args
+        .slice()
+        .reverse());
+    
+    __body.body.unshift(push);
+    
+    const last = __body.body.at(-1);
+    
+    if (isReturnStatement(last))
+        __body.body.splice(-1, 1, pop, last);
+    else
+        __body.body.push(pop);
+}
+
+function createStackOperation(name, args) {
+    const callee = identifier(name);
+    const params = [
+        arrayExpression(args),
+    ];
+    
+    return expressionStatement(callExpression(callee, params));
+}

package/lib/convert-if-to-jmp/index.js

@@ -0,0 +1,166 @@
+import {types, operator} from 'putout';
+import {parseOperator} from './operator.js';
+
+const {
+    callExpression,
+    labeledStatement,
+    identifier,
+    isLabeledStatement,
+    isBinaryExpression,
+    isArrayExpression,
+    isLogicalExpression,
+} = types;
+
+const {
+    replaceWith,
+    insertAfter,
+    extract,
+} = operator;
+
+const createName = (suffix, type) => {
+    return `__nirguna_fasm_if_${type}_${suffix}`;
+};
+
+export const report = () => `Use 'jmp' instead of 'if'`;
+export const match = () => ({
+    'if (__a) __b': ({__a}) => {
+        return isBinaryExpression(__a) || isLogicalExpression(__a);
+    },
+    'if (__a) __b; else __c': ({__a}) => isBinaryExpression(__a),
+});
+
+export const replace = ({options}) => {
+    let {labelSuffix = 0} = options;
+    
+    return {
+        'if (__a) __b': (vars, path) => {
+            const next = getNext(path);
+            const name = createName(++labelSuffix, 'end');
+            const test = parseTest(path, name);
+            
+            createLabel(next, name);
+            
+            return `{
+                ${test}
+                __b;
+            }`;
+        },
+        'if (__a) __b; else __c': (vars, path) => {
+            const next = getNext(path);
+            const suffix = ++labelSuffix;
+            const endLabel = createName(suffix, 'end');
+            const elseLabel = createName(suffix, 'else');
+            const test = parseTest(path, elseLabel);
+            
+            createLabel(next, endLabel);
+            
+            return `{
+                ${test}
+                __b;
+                jmp(${endLabel});
+                ${elseLabel}:
+                __c;
+            }`;
+        },
+    };
+};
+
+const maybeBraces = (node, value) => {
+    if (isArrayExpression(node))
+        return `[${value}]`;
+    
+    return value;
+};
+
+function parseBinaryTest({left, right, operator}, options = {}) {
+    const {direct = false} = options;
+    const extractedLeft = extract(left);
+    const extractedRight = extract(right);
+    
+    return [
+        maybeBraces(left, extractedLeft),
+        maybeBraces(right, extractedRight),
+        parseOperator(operator, {
+            direct,
+        }),
+    ];
+}
+
+function parseTest(path, name) {
+    const {test} = path.node;
+    
+    if (isBinaryExpression(test)) {
+        const [first, second, jnz] = parseBinaryTest(test);
+        
+        return `
+            cmp(${first}, ${second});
+            ${jnz}(${name});
+        `;
+    }
+    
+    if (isLogicalExpression(test)) {
+        const {
+            left,
+            right,
+            operator,
+        } = test;
+        
+        if (operator === '&&') {
+            const [firstLeft, secondLeft, jnzLeft] = parseBinaryTest(left);
+            const [firstRight, secondRight, jnzRight] = parseBinaryTest(right);
+            
+            return `
+                cmp(${firstLeft}, ${secondLeft});
+                ${jnzLeft}(${name});
+                cmp(${firstRight}, ${secondRight});
+                ${jnzRight}(${name});
+            `;
+        }
+        
+        if (operator === '||') {
+            const [firstLeft, secondLeft, jzLeft] = parseBinaryTest(left, {
+                direct: true,
+            });
+            
+            const [firstRight, secondRight, jnzRight] = parseBinaryTest(right);
+            
+            const nameOr = name.replace('end', 'or');
+            
+            return `
+                cmp(${firstLeft}, ${secondLeft});
+                ${jzLeft}(${nameOr});
+                cmp(${firstRight}, ${secondRight});
+                ${jnzRight}(${name});
+                ${nameOr}:
+            `;
+        }
+    }
+}
+
+function createLabel(path, name) {
+    const labelName = identifier(name);
+    const label = labeledStatement(labelName, path.node);
+    
+    replaceWith(path, label);
+}
+
+const getLatestLabeledStatement = (path) => {
+    do {
+        path = path.parentPath;
+    } while (isLabeledStatement(path.parentPath));
+    return path;
+};
+
+function getNext(path) {
+    const next = path.getNextSibling();
+    
+    if (next.node)
+        return next;
+    
+    if (path.parentPath.isLabeledStatement())
+        path = getLatestLabeledStatement(path);
+    
+    insertAfter(path, callExpression(identifier('nop'), []));
+    
+    return path.getNextSibling();
+}

package/lib/convert-if-to-jmp/operator.js

@@ -0,0 +1,27 @@
+const OPERATOR = {
+    '===': 'jz',
+    '!==': 'jnz',
+    '>': 'jg',
+    '<': 'jl',
+    '<=': 'jle',
+    '>=': 'jge',
+};
+
+const OPERATOR_REVERSE = {
+    '===': 'jnz',
+    '!==': 'jz',
+    '>': 'jle',
+    '<': 'jge',
+    '<=': 'jg',
+    '>=': 'jl',
+};
+
+export function parseOperator(operator, {direct = false}) {
+    const customOperator = direct ? OPERATOR : OPERATOR_REVERSE;
+    const result = customOperator[operator];
+    
+    if (!result)
+        throw Error(`☝️Looks like operator '${operator}' not supported`);
+    
+    return result;
+}

package/lib/convert-linux-exit-to-syscall/index.js

@@ -0,0 +1,15 @@
+export const report = () => `Use 'syscall' instead of 'linux.exit()'`;
+
+export const match = () => ({
+    'linux.exit(__a)': (vars, path) => {
+        return path.parentPath.isExpressionStatement();
+    },
+});
+
+export const replace = () => ({
+    'linux.exit(__a)': `{
+        rdi = __a;
+        rax = 60;
+        syscall();
+    }`,
+});