docs: def loadXml(self, xdata, filepath=''):
          """
          Loads properties from the xml data.
          
          :param      xdata | <xml.etree.ElementTree.Element>
          """
          # build options
          opts = {'platform': sys.platform}
  
          mkpath = lambda x: _mkpath(filepath, x, **opts)
  
          # lookup environment variables
          xenv = xdata.find('environment')
          if xenv is not None:
              env = {}
              log.info('loading environment...')
              for xkey in xenv:
                  text = xkey.text
                  if text:
                      env[xkey.tag] = os.path.expandvars(text)
                  else:
                      env[xkey.tag] = ''
  
              self.setEnvironment(env)
  
          # lookup general settings
          xsettings = xdata.find('settings')
          if xsettings is not None:
              for xsetting in xsettings:
                  key = xsetting.tag
                  val = xsetting.text
                  attr = '_' + key
                  if hasattr(self, attr):
                      setattr(self, attr, val)
  
          # lookup options
          xoptions = xdata.find('options')
          if xoptions is not None:
              options = 0
              for xopt in xoptions:
                  key = xopt.tag
                  value = xopt.text
  
                  if value.lower() == 'true':
                      try:
                          options |= Builder.Options[key]
                      except KeyError:
                          continue
  
              self._options = options
  
          # lookup path options
          xpaths = xdata.find('paths')
          if xpaths is not None:
              for xpath in xpaths:
                  key = xpath.tag
                  path = xpath.text
  
                  if key.endswith('Paths'):
                      path = map(mkpath, path.split(';'))
                  else:
                      path = mkpath(path)
  
                  setattr(self, '_' + key, path)
  
          # lookup executable options
          xexe = xdata.find('executable')
          if xexe is not None:
              exe_tags = {'runtime': '_runtime',
                          'exe': '_executableName',
                          'cli': '_executableCliName',
                          'product': '_productName'}
  
              for tag, prop in exe_tags.items():
                  xtag = xexe.find(tag)
                  if xtag is not None:
                      value = xtag.text
                      if value.startswith('.'):
                          value = mkpath(value)
  
                      setattr(self, prop, value)
  
              # load exclude options
              xexcludes = xexe.find('excludes')
              if xexcludes is not None:
                  excludes = []
                  for xexclude in xexcludes:
                      excludes.append(xexclude.text)
                  self.setExecutableExcludes(excludes)
  
              # load build data
              xexedata = xexe.find('data')
              if xexedata is not None:
                  data = []
                  for xentry in xexedata:
                      if xentry.tag == 'tree':
                          path = xentry.get('path', '')
                          if path:
                              path = mkpath(path)
                          else:
                              path = self.sourcePath()
  
                          prefix = xentry.get('prefix', os.path.basename(path))
                          excludes = xentry.get('excludes', '').split(';')
  
                          if excludes:
                              data.append(('tree', (path, prefix, excludes)))
                      else:
                          for xitem in xentry:
                              data.append((xentry.tag, xitem.attrs))
  
                  self.setExecutableData(data)
  
              # load hidden imports
              xhiddenimports = xexe.find('hiddenimports')
              if xhiddenimports is not None:
                  imports = []
                  for ximport in xhiddenimports:
                      imports.append(ximport.text)
                  self.setHiddenImports(imports)
  
              # load options
              xopts = xexe.find('options')
              if xopts is not None:
                  for xopt in xopts:
                      if xopt.text.startswith('.'):
                          value = mkpath(xopt.text)
                      else:
                          value = xopt.text
                      self._executableOptions[xopt.tag] = value
  
          # lookup installer options
          xinstall = xdata.find('installer')
          if xinstall is not None:
              install_tags = {'name': '_installName'}
  
              for tag, prop in install_tags.items():
                  xtag = xinstall.find(tag)
                  if xtag is not None:
                      value = xtag.text
                      if value.startswith('.'):
                          value = mkpath(value)
                      setattr(self, prop, value)
  
              xopts = xinstall.find('options')
              if xopts is not None:
                  for xopt in xopts:
                      if xopt.text.startswith('.'):
                          value = mkpath(xopt.text)
                      else:
                          value = xopt.text
  
                      self._installerOptions[xopt.tag] = value
  
              xdirectories = xinstall.find('additional_directories')
              if xdirectories is not None:
                  for xdir in xdirectories:
                      self._installDirectories[xdir.get('path')] = xdir.get('source', '')