@nirguna/plugin-fasm 1.0.0

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

@@ -0,0 +1,48 @@
+import {operator, types} from 'putout';
+
+const {isArrayExpression} = types;
+const {extract} = operator;
+const STDOUT = 1;
+
+export const report = () => `Use 'syscall' instead of 'linux.write()'`;
+
+export const match = () => ({
+    'linux.write()': (vars, path) => {
+        return path.parentPath.isExpressionStatement();
+    },
+});
+
+export const replace = () => ({
+    'linux.write(__object)': ({__object}) => {
+        const {
+            descriptor = STDOUT,
+            message = 0,
+            length = 0,
+        } = parseArgs(__object.properties);
+        
+        return `{
+            rdi = ${descriptor};
+            rsi = ${message};
+            rdx = ${length};
+            rax = 1;
+            syscall();
+        }`;
+    },
+});
+
+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-mov-to-add/index.js

@@ -0,0 +1,5 @@
+export const report = () => `Use 'add' instead of 'mov'`;
+
+export const replace = () => ({
+    'mov(__a, __a + __b)': 'add(__a, __b)',
+});

package/lib/convert-return-to-eax/index.js

@@ -0,0 +1,76 @@
+import {types} from 'putout';
+
+const {isFunction} = types;
+const i16 = [
+    'ax',
+    'bx',
+    'cx',
+    'dx',
+    'di',
+    'si',
+];
+
+export const report = () => `Use 'eax' instead of 'return'`;
+
+export const replace = () => ({
+    'return': 'ret()',
+    'return __a': ({__a}, path) => {
+        if (i16.includes(__a.name))
+            return `{
+                ax = __a;
+                ret();
+            }`;
+        
+        const fnPath = path.find(isFunction);
+        
+        if (fnPath) {
+            const {returnType} = fnPath.node;
+            
+            if (!fnPath.node.params.length)
+                delete fnPath.node.returnType;
+            
+            const name = parseType(fnPath, returnType);
+            
+            const reg = getReg(name);
+            
+            return `{
+                ${reg} = __a;
+                ret();
+            }`;
+        }
+        
+        return `{
+            ax = __a;
+            ret();
+        }`;
+    },
+});
+
+function parseType(path, returnType) {
+    const {__nirguna_return_type} = path;
+    
+    if (__nirguna_return_type)
+        return __nirguna_return_type;
+    
+    if (!returnType)
+        return '';
+    
+    const {name} = returnType.typeAnnotation.typeName;
+    
+    path.__nirguna_return_type = name;
+    
+    return name;
+}
+
+function getReg(name) {
+    if (name === 'i8')
+        return 'al';
+    
+    if (name === 'i32')
+        return 'eax';
+    
+    if (name === 'i64')
+        return 'rax';
+    
+    return 'ax';
+}

package/lib/convert-strncmp-to-repe-cmpsb/index.js

@@ -0,0 +1,23 @@
+export const report = () => `Use 'repe.cmbsp()' instead of 'strncmp()'`;
+
+export const match = () => ({
+    'strncmp(__a, __b, __c)': (vars, path) => {
+        return path.parentPath.isExpressionStatement();
+    },
+});
+
+export const replace = () => ({
+    '__a = strncmp(__b, __c, __d)': `{
+        mov(cx, __d);
+        si = __b;
+    	di =__c 
+        repe.cmpsb();
+        mov(__a, cx);
+    }`,
+    'strncmp(__a, __b, __c)': `{
+        mov(cx, __c);
+        si = __a;
+    	di =__b 
+        repe.cmpsb();
+    }`,
+});

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

@@ -0,0 +1,5 @@
+export const report = () => `Use 'if' instead of 'ternary'`;
+
+export const replace = () => ({
+    '__a = __b ? __c : __d': 'if (__b) __a = __c; else __a = __d',
+});

package/lib/convert-ureg-to-reg/index.js

@@ -0,0 +1,108 @@
+import {operator} from 'putout';
+
+const {keys} = Object;
+const {rename} = operator;
+
+function getBitness(path) {
+    const programPath = path.scope.getProgramParent().path;
+    const {directives} = programPath.node;
+    
+    if (!directives.length)
+        return 16;
+    
+    const {value} = directives[0].value;
+    
+    if (value === 'use 16')
+        return 16;
+    
+    if (value === 'use 32')
+        return 32;
+    
+    if (value === 'use 64')
+        return 64;
+    
+    return '16';
+}
+
+export const report = () => `Use 'reg' instead of 'ureg'`;
+
+export const fix = ({path, names}) => {
+    const bitness = getBitness(path);
+    
+    for (const name of names) {
+        rename(path, name, REG[bitness][name]);
+    }
+    
+    if (path.node.returnType)
+        path.node.returnType.typeAnnotation.typeName.name = `i${bitness}`;
+};
+
+const isUReg = (a) => {
+    return keys(REG_16).includes(a);
+};
+
+const REG_16 = {
+    uax: 'ax',
+    ubx: 'bx',
+    ucx: 'cx',
+    udx: 'dx',
+    usi: 'si',
+    udi: 'di',
+    usp: 'sp',
+    ubp: 'bp',
+};
+
+const REG_32 = {
+    uax: 'eax',
+    ubx: 'ebx',
+    ucx: 'ecx',
+    udx: 'edx',
+    usi: 'esi',
+    udi: 'edi',
+    usp: 'esp',
+    ubp: 'ebp',
+};
+
+const REG_64 = {
+    uax: 'rax',
+    ubx: 'rbx',
+    ucx: 'rcx',
+    udx: 'rdx',
+    usi: 'rsi',
+    udi: 'rdi',
+    usp: 'rsp',
+    ubp: 'rbp',
+};
+
+const REG = {
+    16: REG_16,
+    32: REG_32,
+    64: REG_64,
+};
+
+export const traverse = ({push}) => ({
+    Function(path) {
+        const {bindings} = path.scope;
+        const names = [];
+        
+        for (const name of keys(bindings)) {
+            if (!isUReg(name))
+                continue;
+            
+            names.push(name);
+        }
+        
+        if (!names.length)
+            return;
+        
+        push({
+            path,
+            names,
+        });
+    },
+    Program: {
+        exit(path) {
+            path.node.directives = [];
+        },
+    },
+});

package/lib/convert-while-to-jz/index.js

@@ -0,0 +1,158 @@
+import {
+    template,
+    types,
+    operator,
+    print,
+} from 'putout';
+
+const {
+    compare,
+    extract,
+    replaceWith,
+    insertAfter,
+} = operator;
+
+const {
+    identifier,
+    expressionStatement,
+    isCallExpression,
+    labeledStatement,
+    isBooleanLiteral,
+    isArrayExpression,
+    blockStatement,
+    isBlockStatement,
+} = types;
+
+const createStartLabel = (line) => `__nirguna_while_${line}`;
+const createConditionLabel = (line) => `__nirguna_while_condition_${line}`;
+
+export const report = () => `Use 'jz' instead of 'while'`;
+
+export const replace = () => ({
+    'while(__a) __b': ({__a, __b}, path) => {
+        const {line} = path.node.loc.start;
+        const startLabel = createStartLabel(line);
+        const conditionLabel = createConditionLabel(line);
+        const [one, two, jnz, test] = parseWhileArgs(__a);
+        const endLabel = createEndLabel(path, line);
+        
+        let conditionExpression = createExpression(__a, {
+            one,
+            two,
+            test,
+        });
+        
+        const wasContinue = maybeReplaceContinueWithJmp(path, conditionLabel);
+        
+        if (wasContinue)
+            conditionExpression = labeledStatement(identifier(conditionLabel), conditionExpression);
+        
+        const body = isBlockStatement(__b) ? __b : blockStatement([expressionStatement(__b)]);
+        body.body.unshift(expressionStatement(template.ast(`${jnz}(${endLabel})`)));
+        body.body.unshift(conditionExpression);
+        
+        body.body.push(expressionStatement(template.ast(`jmp(${startLabel})`)));
+        
+        maybeReplaceBreak(path, endLabel);
+        
+        return labeledStatement(identifier(startLabel), body);
+    },
+});
+
+const parseWhileArgs = (__a) => {
+    if (isBooleanLiteral(__a) && __a.value)
+        return [
+            'al',
+            'al',
+            'je',
+            'cmp',
+        ];
+    
+    if (isBooleanLiteral(__a) && !__a.value)
+        return [
+            'al',
+            'al',
+            'je',
+            'cmp',
+        ];
+    
+    if (isArrayExpression(__a))
+        return [
+            'al',
+            'al',
+            'jz',
+            'test',
+        ];
+    
+    if (compare(__a, '__a === __b'))
+        return [
+            extract(__a.left),
+            extract(__a.right),
+            'jz',
+            'test',
+        ];
+    
+    return [
+        __a.name,
+        __a.name,
+        'jz',
+        'test',
+    ];
+};
+
+const printExpression = (a) => print(a).slice(0, -2);
+
+function createExpression(__a, {one, two, test}) {
+    if (isCallExpression(__a)) {
+        const op = printExpression(__a);
+        
+        return blockStatement([
+            expressionStatement(template.ast(op)),
+            expressionStatement(template.ast(`${test}(al, al)`)),
+        ]);
+    }
+    
+    if (isArrayExpression(__a)) {
+        const source = printExpression(__a);
+        
+        return blockStatement([
+            expressionStatement(template.ast(`mov(al, ${source})`)),
+            expressionStatement(template.ast(`${test}(al, al)`)),
+        ]);
+    }
+    
+    return expressionStatement(template.ast(`${test}(${one}, ${two})`));
+}
+
+function maybeReplaceContinueWithJmp(path, startLabel) {
+    let was = false;
+    
+    path.traverse({
+        ContinueStatement(path) {
+            path.replaceWithSourceString(`jmp(${startLabel})`);
+            was = true;
+        },
+    });
+    return was;
+}
+
+function maybeReplaceBreak(path, endLabel) {
+    path.traverse({
+        BreakStatement(path) {
+            path.replaceWithSourceString(`jmp(${endLabel})`);
+        },
+    });
+}
+
+function createEndLabel(path, line) {
+    const endLabel = `__nirguna_while_end_${line}`;
+    const nextPath = path.getNextSibling();
+    const labeledNode = labeledStatement(identifier(endLabel), nextPath.node || expressionStatement(template.ast('nop()')));
+    
+    if (nextPath.node)
+        replaceWith(nextPath, labeledNode);
+    else
+        insertAfter(path, labeledNode);
+    
+    return endLabel;
+}

package/lib/extract-labeled-block/index.js

@@ -0,0 +1,68 @@
+import {types, operator} from 'putout';
+
+const {getTemplateValues} = operator;
+
+const {
+    isProgram,
+    isBlockStatement,
+    isLabeledStatement,
+} = types;
+
+export const report = ({path}) => {
+    const {name} = path.node.label;
+    
+    return `Extract 'labeled' block: '${name}'`;
+};
+
+export const fix = ({path, first, other}) => {
+    path.node.body = first;
+    
+    const index = path.parentPath.node.body.indexOf(path.node);
+    const {body} = path.parentPath.node;
+    
+    body.splice(index + 1, 0, ...other);
+};
+export const traverse = ({push}) => ({
+    '__a: __b: {__body}': (path) => {
+        const {parentPath} = path;
+        
+        if (isProgram(parentPath))
+            return;
+        
+        if (isLabeledStatement(parentPath))
+            return;
+        
+        if (isLabeledStatement(path.node.body))
+            return;
+        
+        const {__body} = getTemplateValues(path, '__a: __b: {__body}');
+        
+        const [first, ...other] = __body.body;
+        
+        if (!isBlockStatement(first))
+            push({
+                path,
+                first,
+                other,
+            });
+    },
+    '__a: {__body}': (path) => {
+        const {parentPath} = path;
+        
+        if (isLabeledStatement(parentPath))
+            return;
+        
+        if (isProgram(parentPath))
+            return;
+        
+        const {__body} = getTemplateValues(path, '__a: {__body}');
+        const [first, ...other] = __body.body;
+        
+        if (!isBlockStatement(first))
+            push({
+                path,
+                first,
+                other,
+            });
+    },
+});

package/lib/index.js

@@ -0,0 +1,93 @@
+import * as removeUselessPromise from './remove-useless-promise/index.js';
+import * as applyInclude from './apply-include/index.js';
+import * as switchCmpOperands from './switch-cmp-operands/index.js';
+import * as splitBinaryExpression from './split-binary-expression/index.js';
+import * as convertLinuxExitToSyscall from './convert-linux-exit-to-syscall/index.js';
+import * as convertLinuxWriteToSyscall from './convert-linux-write-to-syscall/index.js';
+import * as convertWhileToJz from './convert-while-to-jz/index.js';
+import * as convertUregToReg from './convert-ureg-to-reg/index.js';
+import * as convertConstToEqu from './convert-const-to-equ/index.js';
+import * as removeUselessBraces from './remove-useless-braces/index.js';
+import * as applyRegisters from './apply-registers/index.js';
+import * as convertAssignToOr from './convert-assign-to-or/index.js';
+import * as convertAssignToAnd from './convert-assign-to-and/index.js';
+import * as applyTypes from './apply-types/index.js';
+import * as convertArgsToRegs from './convert-args-to-regs/index.js';
+import * as convertTernaryToIf from './convert-ternary-to-if/index.js';
+import * as convertStrncmpToRepeCmpsb from './convert-strncmp-to-repe-cmpsb/index.js';
+import * as convertBiosRebootToJmpFar from './convert-bios-reboot-to-jmp-far/index.js';
+import * as convertBiosReadSectorToInt13 from './convert-bios-read-sector-to-int-13/index.js';
+import * as convertBiosReadCharToInt16 from './convert-bios-read-char-to-int-16/index.js';
+import * as convertBiosScrollToInt10 from './convert-bios-scroll-to-int-10/index.js';
+import * as splitAssignAwaitWithAssignEax from './split-assign-await-with-assign-eax/index.js';
+import * as convertDoWhileToJnz from './convert-do-while-to-jnz/index.js';
+import * as convertBiosPrintLineToInt10 from './convert-bios-print-line-to-int-10/index.js';
+import * as convertBiosClearScreenToInt10 from './convert-bios-clear-screen-to-int-10/index.js';
+import * as convertAssignToSub from './convert-assign-to-sub/index.js';
+import * as applyEquality from './apply-equality/index.js';
+import * as extractLabeledBlock from './extract-labeled-block/index.js';
+import * as convertIfToJmp from './convert-if-to-jmp/index.js';
+import * as removeUselessDeclarations from './remove-useless-declarations/index.js';
+import * as addLabelPrefix from './add-label-prefix/index.js';
+import * as convertDeclarationToToMov from './convert-declaration-to-mov/index.js';
+import * as convertMovToAdd from './convert-mov-to-add/index.js';
+import * as convertReturnToEax from './convert-return-to-eax/index.js';
+import * as applyInc from './apply-inc/index.js';
+import * as convEquCallToMember from './convert-equ-call-to-member/index.js';
+import * as convertDecToHex from './convert-dec-to-hex/index.js';
+import * as convertAssignToMember from './convert-assign-to-member/index.js';
+import * as convertAssignToAdd from './convert-assign-to-add/index.js';
+import * as convertAssignToMov from './convert-assign-to-mov/index.js';
+import * as convertAssignToXor from './convert-assign-to-xor/index.js';
+import * as convertAssignToShl from './convert-assign-to-shl/index.js';
+import * as convertAwaitToCall from './convert-await-to-call/index.js';
+import * as splitStackOperations from './split-stack-operations/index.js';
+import * as convertFunctionToLabel from './convert-function-to-label/index.js';
+
+export const rules = {
+    'apply-types': applyTypes,
+    'convert-dec-to-hex': convertDecToHex,
+    'convert-equ-call-to-member': convEquCallToMember,
+    'convert-assign-to-member': convertAssignToMember,
+    'convert-assign-to-add': convertAssignToAdd,
+    'convert-assign-to-mov': convertAssignToMov,
+    'convert-assign-to-xor': convertAssignToXor,
+    'convert-assign-to-shl': convertAssignToShl,
+    'convert-function-to-label': convertFunctionToLabel,
+    'convert-await-to-call': convertAwaitToCall,
+    'split-stack-operations': splitStackOperations,
+    'apply-inc': applyInc,
+    'convert-return-to-eax': convertReturnToEax,
+    'convert-mov-to-add': convertMovToAdd,
+    'convert-declaration-to-mov': convertDeclarationToToMov,
+    'add-label-prefix': addLabelPrefix,
+    'remove-useless-declarations': removeUselessDeclarations,
+    'convert-if-to-jmp': convertIfToJmp,
+    'extract-labeled-block': extractLabeledBlock,
+    'apply-equality': applyEquality,
+    'convert-assign-to-sub': convertAssignToSub,
+    'convert-bios-clear-screen-to-int-10': convertBiosClearScreenToInt10,
+    'convert-bios-print-line-to-int-10': convertBiosPrintLineToInt10,
+    'convert-do-while-to-jnz': convertDoWhileToJnz,
+    'split-assign-await-with-assign-eax': splitAssignAwaitWithAssignEax,
+    'convert-bios-scroll-to-int-10': convertBiosScrollToInt10,
+    'convert-bios-read-char-to-int-16': convertBiosReadCharToInt16,
+    'convert-bios-read-sector-to-int-13': convertBiosReadSectorToInt13,
+    'convert-bios-reboot-to-jmp-far': convertBiosRebootToJmpFar,
+    'convert-strncmp-to-repe-cmpsb': convertStrncmpToRepeCmpsb,
+    'convert-ternary-to-if': convertTernaryToIf,
+    'convert-args-to-regs': convertArgsToRegs,
+    'convert-assign-to-and': convertAssignToAnd,
+    'convert-assign-to-or': convertAssignToOr,
+    'apply-registers': applyRegisters,
+    'remove-useless-braces': removeUselessBraces,
+    'convert-const-to-equ': convertConstToEqu,
+    'convert-ureg-to-reg': convertUregToReg,
+    'convert-while-to-jz': convertWhileToJz,
+    'convert-linux-write-to-syscall': convertLinuxWriteToSyscall,
+    'convert-linux-exit-to-syscall': convertLinuxExitToSyscall,
+    'split-binary-expression': splitBinaryExpression,
+    'switch-cmp-operands': switchCmpOperands,
+    'apply-include': applyInclude,
+    'remove-useless-promise': removeUselessPromise,
+};

package/lib/remove-useless-braces/index.js

@@ -0,0 +1,5 @@
+export const report = () => `Avoid useless braces`;
+
+export const replace = () => ({
+    '[[__b]]': '[__b]',
+});

package/lib/remove-useless-declarations/index.js

@@ -0,0 +1,7 @@
+export const report = () => `Avoid useless import of '#operator-fasm'`;
+
+export const replace = () => ({
+    'import __imports from "#operator-fasm"': '',
+    'import __imports from "@nirguna/operator-fasm"': '',
+    'export {__exports}': '',
+});

package/lib/remove-useless-promise/index.js

@@ -0,0 +1,5 @@
+export const report = () => `Avoid useless 'Promise' type`;
+
+export const replace = () => ({
+    'async function __a(__args): Promise<__b> {__body}': 'async function __a(__args): __b {__body}',
+});

package/lib/split-assign-await-with-assign-eax/index.js

@@ -0,0 +1,41 @@
+import {
+    is32bit,
+    is64bit,
+    is8bit,
+} from '@nirguna/operator-fasm/regs';
+
+export const report = () => `Get result from 'eax'`;
+
+const getEax = (name) => {
+    if (is8bit(name))
+        return 'al';
+    
+    if (is32bit(name))
+        return 'eax';
+    
+    if (is64bit(name))
+        return 'rax';
+    
+    return 'ax';
+};
+
+export const replace = () => ({
+    '__a = await __b(__args)': ({__a}) => {
+        const eax = getEax(__a.name);
+        
+        return `{
+            __a = ${eax};
+            await __b(__args);
+            xchg(__a, ${eax});
+        }`;
+    },
+    '__a: __b = await __c(__args)': ({__b}) => {
+        const eax = getEax(__b.name);
+        
+        return `{
+            __b = ${eax};
+            __a: await __c(__args);
+            xchg(__b, ${eax});
+        }`;
+    },
+});

package/lib/split-binary-expression/index.js

@@ -0,0 +1,31 @@
+import {operator, types} from 'putout';
+
+const {
+    isIdentifier,
+    isMemberExpression,
+} = types;
+
+const {compare} = operator;
+
+export const report = () => `Split 'binary expression'`;
+
+export const match = () => ({
+    '__a = __b + __c': ({__c, __a}) => {
+        if (isIdentifier(__c) && /[A-Z]/.test(__c.name))
+            return false;
+        
+        return !isMemberExpression(__a);
+    },
+});
+
+export const replace = () => ({
+    '__a = __b + __c': ({__a, __b}) => {
+        if (compare(__a, __b))
+            return '__a += __c';
+        
+        return `{
+    	__a = __b;
+        __a += __c
+    }`;
+    },
+});