@neo-one/smart-contract-compiler-esnext-esm/compile/helper/types/string/ToStringHelper.js

NEO•ONE TypeScript smart contract compiler.

import { Types } from '../../../constants';
import { TypedHelper } from '../TypedHelper';
export class ToStringHelper extends TypedHelper {
    constructor({ initial = true, type, knownType }) {
        super({ type, knownType });
        this.initial = initial;
    }
    emit(sb, node, optionsIn) {
        if (!optionsIn.pushValue) {
            sb.emitOp(node, 'DROP');
            return;
        }
        const convertUndefined = () => {
            sb.emitOp(node, 'DROP');
            sb.emitPushString(node, 'undefined');
        };
        const convertNull = () => {
            sb.emitOp(node, 'DROP');
            sb.emitPushString(node, 'null');
        };
        const convertBoolean = (options) => {
            sb.emitHelper(node, options, sb.helpers.if({
                condition: () => {
                    sb.emitHelper(node, options, sb.helpers.unwrapBoolean);
                },
                whenTrue: () => {
                    sb.emitPushString(node, 'true');
                },
                whenFalse: () => {
                    sb.emitPushString(node, 'false');
                },
            }));
        };
        const convertNumber = (options) => {
            const n = sb.scope.addUnique();
            const accum = sb.scope.addUnique();
            sb.emitHelper(node, options, sb.helpers.unwrapNumber);
            sb.emitHelper(node, options, sb.helpers.if({
                condition: () => {
                    sb.emitOp(node, 'DUP');
                    sb.emitPushInt(node, 0);
                    sb.emitOp(node, 'NUMEQUAL');
                },
                whenTrue: () => {
                    sb.emitOp(node, 'DROP');
                    sb.emitPushString(node, '0');
                },
                whenFalse: () => {
                    sb.scope.set(sb, node, options, n);
                    sb.emitPushBuffer(node, Buffer.from([]));
                    sb.scope.set(sb, node, options, accum);
                    sb.emitHelper(node, options, sb.helpers.forLoop({
                        condition: () => {
                            sb.scope.get(sb, node, options, n);
                            sb.emitPushInt(node, 0);
                            sb.emitOp(node, 'GT');
                        },
                        each: () => {
                            sb.scope.get(sb, node, options, n);
                            sb.emitOp(node, 'DUP');
                            sb.emitPushInt(node, 10);
                            sb.emitOp(node, 'DIV');
                            sb.scope.set(sb, node, options, n);
                            sb.emitPushInt(node, 10);
                            sb.emitOp(node, 'MOD');
                            sb.emitPushInt(node, 0x30);
                            sb.emitOp(node, 'ADD');
                            sb.scope.get(sb, node, options, accum);
                            sb.emitOp(node, 'CAT');
                            sb.scope.set(sb, node, options, accum);
                        },
                        cleanup: () => {
                        },
                    }));
                    sb.scope.get(sb, node, options, accum);
                },
            }));
        };
        const convertString = (options) => {
            sb.emitHelper(node, options, sb.helpers.unwrapString);
        };
        const throwTypeError = (options) => {
            sb.emitOp(node, 'DROP');
            sb.emitHelper(node, options, sb.helpers.throwTypeError);
        };
        const convertObject = (options) => {
            sb.emitHelper(node, options, sb.helpers.toPrimitive({ type: this.type, preferredType: 'string' }));
            doConvert(options, false);
        };
        const convertArray = (options) => {
            sb.emitHelper(node, options, sb.helpers.unwrapArray);
            sb.emitHelper(node, options, sb.helpers.arrToString({ type: this.type, knownType: Types.Array }));
        };
        const convertEmptyString = () => {
            sb.emitOp(node, 'DROP');
            sb.emitPushString(node, '');
        };
        const convertBuffer = (innerOptions) => {
            sb.emitHelper(node, innerOptions, sb.helpers.unwrapBuffer);
        };
        const doConvert = (options, initial) => {
            sb.emitHelper(node, options, sb.helpers.forBuiltinType({
                type: initial ? this.type : undefined,
                knownType: initial ? this.knownType : undefined,
                array: initial ? convertArray : throwTypeError,
                arrayStorage: convertEmptyString,
                boolean: convertBoolean,
                buffer: convertBuffer,
                null: convertNull,
                number: convertNumber,
                object: initial ? convertObject : throwTypeError,
                string: convertString,
                symbol: throwTypeError,
                undefined: convertUndefined,
                map: convertEmptyString,
                mapStorage: convertEmptyString,
                set: convertEmptyString,
                setStorage: convertEmptyString,
                error: convertEmptyString,
                forwardValue: convertEmptyString,
                iteratorResult: convertEmptyString,
                iterable: convertEmptyString,
                iterableIterator: convertEmptyString,
                transaction: convertEmptyString,
                output: convertEmptyString,
                attribute: convertEmptyString,
                input: convertEmptyString,
                account: convertEmptyString,
                asset: convertEmptyString,
                contract: convertEmptyString,
                header: convertEmptyString,
                block: convertEmptyString,
            }));
        };
        doConvert(optionsIn, this.initial);
    }
}

//# sourceMappingURL=ToStringHelper.js.map