Generates the executable for this builder in the output path.
        
        :param      outpath | <str>

def generateExecutable(self, outpath='.', signed=False):
        """
        Generates the executable for this builder in the output path.
        
        :param      outpath | <str>
        """
        if not (self.runtime() or self.specfile()):
            return True

        if not self.distributionPath():
            return True

        if os.path.exists(self.distributionPath()):
            shutil.rmtree(self.distributionPath())

        if os.path.isfile(self.sourcePath()):
            basepath = os.path.normpath(os.path.dirname(self.sourcePath()))
        else:
            basepath = os.path.normpath(self.sourcePath())

        # store the plugin table of contents
        self.generatePlugins(basepath)

        # generate the specfile if necessary
        specfile = self.specfile()
        # generate the spec file options
        opts = {
            'name': self.name(),
            'exname': self.executableName(),
            'product': self.productName(),
            'runtime': self.runtime(),
            'srcpath': self.sourcePath(),
            'buildpath': self.buildPath(),
            'hookpaths': ',\n'.join(wrap_str(self.hookPaths())),
            'hiddenimports': ',\n'.join(wrap_str(self.hiddenImports())),
            'distpath': self.distributionPath(),
            'platform': sys.platform,
            'excludes': ',\n'.join(wrap_str(self.executableExcludes()))
        }

        if not specfile:
            datasets = []
            for typ, data in self.executableData():
                if typ == 'tree':
                    args = {
                        'path': data[0],
                        'prefix': data[1],
                        'excludes': ','.join(wrap_str(data[2]))
                    }

                    datasets.append(templ.SPECTREE.format(**args))

                else:
                    args = {}
                    args.update(data)
                    args.setdefault('type', typ)
                    datasets.append(templ.SPECDATA.format(**args))

            opts['datasets'] = '\n'.join(datasets)

            opts.update(self._executableOptions)

            if self.executableCliName():
                opts['cliname'] = self.executableCliName()
                opts['collect'] = templ.SPECFILE_CLI.format(**opts)
            else:
                opts['collect'] = templ.SPECFILE_COLLECT.format(**opts)

            if opts['onefile']:
                data = templ.SPECFILE_ONEFILE.format(**opts)
            else:
                data = templ.SPECFILE.format(**opts)

            # generate the spec file for building
            specfile = os.path.join(self.buildPath(), self.name() + '.spec')
            f = open(specfile, 'w')
            f.write(data)
            f.close()

        cmd = os.path.expandvars(self.executableOption('cmd'))
        success = cmdexec(cmd.format(spec=specfile)) == 0
        if signed:
            binfile = os.path.join(opts['distpath'],
                                   opts['product'],
                                   opts['exname'] + '.exe')
            self.sign(binfile)

        return success