unpackdev / solgo / 8960975808

func NewInstructionTree(instruction Instruction) *InstructionTree {

        return &InstructionTree{

                Instruction: instruction,

                Children:    []*InstructionTree{},

        }

}

func buildInstructionTree(instructions []Instruction, offset int) (*InstructionTree, int, error) {

        // Check if offset is out of range

        if offset < 0 || offset >= len(instructions) {

                return nil, offset, errors.New("offset out of range")

        }

        root := NewInstructionTree(instructions[offset])

        // Start from the next instruction after the root

        nextOffset := offset + 1

        // Iterate through the instructions to find child nodes

        for nextOffset < len(instructions) {

                inst := instructions[nextOffset]

                if isChildOf(root.Instruction, inst) {

                        child, newOffset, err := buildInstructionTree(instructions, nextOffset)

                        if err != nil {

                                return nil, offset, err

                        }

                        root.Children = append(root.Children, child)

                        nextOffset = newOffset

                } else {

                        break

        return root, nextOffset, nil

func isChildOf(parent, child Instruction) bool {

        // Check if the child instruction's offset is greater than the parent instruction's offset

        if child.Offset <= parent.Offset {

                return false

        }

        if child.Offset >= parent.Offset && child.Offset < parent.Offset+len(parent.Args) {

                return true

        }

        for _, opcode := range controlFlowOpcodes {

                if child.OpCode == opcode {

                        return true

                }

        return false