@neo-one/smart-contract-compiler/dist/cjs/compile/helper/iterableIterator/CreateIterableIteratorBaseHelper.js

NEO•ONE TypeScript smart contract compiler.

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.CreateIterableIteratorBaseHelper = void 0;
const constants_1 = require("../../constants");
const Helper_1 = require("../Helper");
class CreateIterableIteratorBaseHelper extends Helper_1.Helper {
    constructor({ handleNext, hasFilter = false }) {
        super();
        this.handleNext = handleNext;
        this.hasFilter = hasFilter;
    }
    emit(sb, node, options) {
        if (!options.pushValue) {
            sb.emitOp(node, 'DROP');
            return;
        }
        sb.emitOp(node, 'NEWMAP');
        sb.emitOp(node, 'TUCK');
        sb.emitPushInt(node, constants_1.IterableIteratorSlots.internalIterator);
        sb.emitOp(node, 'ROT');
        sb.emitOp(node, 'SETITEM');
        sb.emitOp(node, 'DUP');
        sb.emitHelper(node, options, sb.helpers.wrapIterableIterator);
        sb.emitOp(node, 'TUCK');
        sb.emitOp(node, 'OVER');
        sb.emitOp(node, 'OVER');
        sb.emitHelper(node, options, sb.helpers.createFunctionArray({
            body: (innerOptionsIn) => {
                const innerOptions = sb.pushValueOptions(innerOptionsIn);
                sb.emitOp(node, 'DROP');
                sb.scope.getThis(sb, node, innerOptions);
                sb.emitHelper(node, innerOptions, sb.helpers.return);
            },
        }));
        sb.emitHelper(node, options, sb.helpers.bindFunctionThis({ overwrite: true }));
        sb.emitPushInt(node, constants_1.IterableIteratorSlots.iterator);
        sb.emitOp(node, 'SWAP');
        sb.emitOp(node, 'SETITEM');
        sb.emitHelper(node, options, sb.helpers.createFunctionArray({
            body: (innerOptionsIn) => {
                const innerOptions = sb.pushValueOptions(innerOptionsIn);
                sb.emitOp(node, 'DROP');
                sb.scope.getThis(sb, node, innerOptions);
                sb.emitHelper(node, innerOptions, sb.helpers.unwrapIterableIterator);
                sb.emitPushInt(node, constants_1.IterableIteratorSlots.internalIterator);
                sb.emitOp(node, 'PICKITEM');
                if (this.hasFilter) {
                    sb.emitHelper(node, innerOptions, sb.helpers.forLoop({
                        condition: () => {
                            sb.emitHelper(node, innerOptions, sb.helpers.if({
                                condition: () => {
                                    sb.emitOp(node, 'DUP');
                                    sb.emitSysCall(node, 'Neo.Enumerator.Next');
                                },
                                whenTrue: () => {
                                    sb.emitHelper(node, innerOptions, sb.helpers.if({
                                        condition: () => {
                                            sb.emitOp(node, 'DUP');
                                            this.handleNext(innerOptions);
                                        },
                                        whenTrue: () => {
                                            sb.emitOp(node, 'NIP');
                                            sb.emitPushBoolean(node, false);
                                            sb.emitHelper(node, innerOptions, sb.helpers.wrapBoolean);
                                            sb.emitPushBoolean(node, false);
                                        },
                                        whenFalse: () => {
                                            sb.emitOp(node, 'DROP');
                                            sb.emitPushBoolean(node, true);
                                        },
                                    }));
                                },
                                whenFalse: () => {
                                    sb.emitOp(node, 'DROP');
                                    sb.emitHelper(node, innerOptions, sb.helpers.wrapUndefined);
                                    sb.emitPushBoolean(node, true);
                                    sb.emitHelper(node, innerOptions, sb.helpers.wrapBoolean);
                                    sb.emitPushBoolean(node, false);
                                },
                            }));
                        },
                        each: () => {
                        },
                        cleanup: () => {
                        },
                    }));
                }
                else {
                    sb.emitHelper(node, innerOptions, sb.helpers.if({
                        condition: () => {
                            sb.emitOp(node, 'DUP');
                            sb.emitSysCall(node, 'Neo.Enumerator.Next');
                        },
                        whenTrue: () => {
                            this.handleNext(innerOptions);
                            sb.emitPushBoolean(node, false);
                            sb.emitHelper(node, innerOptions, sb.helpers.wrapBoolean);
                        },
                        whenFalse: () => {
                            sb.emitOp(node, 'DROP');
                            sb.emitHelper(node, innerOptions, sb.helpers.wrapUndefined);
                            sb.emitPushBoolean(node, true);
                            sb.emitHelper(node, innerOptions, sb.helpers.wrapBoolean);
                        },
                    }));
                }
                sb.emitHelper(node, innerOptions, sb.helpers.createIteratorResult);
                sb.emitHelper(node, innerOptions, sb.helpers.return);
            },
        }));
        sb.emitHelper(node, options, sb.helpers.bindFunctionThis({ overwrite: true }));
        sb.emitPushInt(node, constants_1.IterableIteratorSlots.next);
        sb.emitOp(node, 'SWAP');
        sb.emitOp(node, 'SETITEM');
    }
}
exports.CreateIterableIteratorBaseHelper = CreateIterableIteratorBaseHelper;

//# sourceMappingURL=CreateIterableIteratorBaseHelper.js.map