Function onloadend

helpers/macho/macho.js:158–305

(e)

    }

    const onloadend = function (e) {

        // console.log( 'Load complete', e )

        let fileType = mime_binary;

        //Handle the file buffer and eventually create a Blob of the result
        // blobUtil.
        arrayBufferToBlob(e.target.result, fileType).then(function(blob) {

            let filesize =  ((blob.size / 1024) / 1024); //Calculate FileSize in Megabyte
            tempFile = blob;

            //Set up the file and print out for verbosity
            machoOutputData.file = file
            machoOutputData.fileSize = filesize
            machoOutputData.architectures = []
            // writeToCallback('<td><strong>File</strong></td><td>'+file.name.toString()+'</td>');
            // writeToCallback('<td><strong>Size</strong></td><td>' + filesize.toFixed(2).toString() + 'MB</td>');

            //Construct a new 8-bit array from the file buffer
            let data = new Uint8Array(e.target.result);
            let magics = FindMagic(data, false); //Try to find all Mach-O magics in the byte array

            // if ( process.env.DEBUG ) { console.log('Parsing all magics...'); }

            //If magics where found, parse the binary.
            if(magics.length > 0) {

                for(var cMagic = 0; cMagic < magics.length; cMagic++) { //Start parsing the binary from each found magic's offset

                    const architecture = {}

                    let magicOff = magics[cMagic]; //The offset of the magic currently being parsed
                    let magic = ReadUint32(data, magicOff); //Read the magic from the byte array
                    let littleendian = MAGIC.ISLITTLEENDIAN(magic); //Get the endianness of the magic
                    let x64 = MAGIC.IS64BIT(magic); //Check which bit architecture is being used

                    // machoOutputData = {}; //Create the Mach-O information object
                    architecture.bits = (x64 ? "64-bit" : "32-bit"); //Get the architecture
                    architecture.endianness = (littleendian ? "little endian" : "big endian"); //Get the endianness
                    architecture.header = (x64 ? new MachoHeader64() : new MachoHeader()); //Depending on architecture, construct a new header
                    architecture.header.magic = magic; //Add the magic to the header
                    architecture.header.cputype = (littleendian ? ReadUint16LE(data, magicOff+uint32_t) : ReadUint16(data, magicOff+uint32_t)); //Read the cputype which comes after the magic
                    architecture.header.cpusubtype = (littleendian ? ReadUint16LE(data, magicOff+(2*uint32_t)) : ReadUint16(data, magicOff+(2*uint32_t))); //Read the cpu subtype which comes after the cputype
                    architecture.header.filetype = (littleendian ? ReadUint32LE(data, magicOff+(3*uint32_t)) : ReadUint32(data, magicOff+(3*uint32_t))); //Read the file type which comes after the cpu subtype
                    architecture.header.ncmds = (littleendian ? ReadUint32LE(data, magicOff+(4*uint32_t)) : ReadUint32(data, magicOff+(4*uint32_t))); //Read the number of commands which comes after the filetype
	                architecture.header.sizeofcmds =(littleendian ? ReadUint32LE(data, magicOff+(5*uint32_t)) : ReadUint32(data, magicOff+(5*uint32_t))); //Read the size of the commands which comes after the number of commands
	                architecture.header.flags = (littleendian ? ReadUint32LE(data, magicOff+(6*uint32_t)) : ReadUint32(data, magicOff+(6*uint32_t))); //Read the flags which come after the size of the commands
	                architecture.loadcommands = [];

	                var align = (x64 ? uint64_t : uint32_t); //Depending on our architecture set an align for parsing the load commands

	                for(var i = 0, off = magicOff; off < data.length, i < architecture.header.ncmds; i++) {

	                	var curr_cmd = {};
	                	curr_cmd.cmd = (littleendian ? ReadUint32LE(data, off) : ReadUint32(data, off)); //Read the command type from the offset
	                	curr_cmd.cmdsize = (littleendian ? ReadUint32LE(data, off+align) : ReadUint32(data, off+align)); //Read the size of the command from the offset