ewinst.py

import collections
import configparser
import os
import re
import sys
import winreg

import cfg
import log

REG_PATH = r'SOFTWARE\WOW6432Node\Microsoft\Windows\CurrentVersion\Uninstall'

installations = collections.OrderedDict()


def listsubdirs(d):
    r = []
    try:
        for f in os.listdir(d):
            if os.path.isdir(os.path.join(d, f)):
                r.append(f)
    except IOError:
        print('ERROR: could not read subdirs in ' + d)
    return r


def find_tkdir(dr, subd=None):
    if not subd:
        subd = listsubdirs(dr)
    if 'common' in subd:
        subd.remove('common')
    if 'install-info' in subd:
        subd.remove('install-info')
    for d in subd:
        if os.path.isfile(os.path.join(dr, d, 'bin', 'icc' + d + '.exe')):
            return os.path.join(dr, d)
    return None


def find_idepm(ew_dir):
    common_bin = os.path.join(ew_dir, 'common', 'bin')
    iaridepm = os.path.join(common_bin, 'IarIdePm.exe')
    if os.path.isfile(iaridepm):
        return iaridepm
    iaride = os.path.join(common_bin, 'iaride.exe')
    if os.path.isfile(iaride):
        return iaride
    return None


class EwInst:
    def __init__(self, ewkey, ew_dir, src, tk=None):
        self.key = _make_unique(ewkey)
        self.info = collections.OrderedDict()
        self.ew_dir = ew_dir
        self.source = src
        self.ide_exe = None
        self.toolkit_dir = tk
        installations[self.key] = self

    def set_attr(self, k, v):
        if k == 'EW_DIR':
            return
        self.info[k] = str(v).strip()
        if k == 'TOOLKIT_DIR':
            self.toolkit_dir = v.strip()
        elif k == 'IDE_EXE':
            self.ide_exe = v.strip()

    def __str__(self): return self.key

    def check(self):
        if not self.ide_exe:
            self.ide_exe = find_idepm(self.ew_dir)
        if not self.toolkit_dir:
            self.toolkit_dir = find_tkdir(self.ew_dir)

    def get_info(self):
        def p(k, v):
            return '  ' + k + ': ' + str(v) + '\n'
        msg = '[' + self.key + ']\n'
        for k, v in [('EW_DIR', self.ew_dir), ('SRC', self.source)]:
            if v:
                msg += p(k, v)
        for k, v in self.info.items():
            msg += p(k, v)
        return msg


def _shortname(ver):
    for r in cfg.shortname:
        ver = re.sub(r, cfg.shortname[r], ver, flags=re.I)
    return ver


def get(version_) -> EwInst:
    version = _shortname(version_).casefold()
    if len(version) == 0:
        return None
    found = None
    for ew in installations.values():
        ewkey = ew.key.casefold()
        if version == ewkey:
            return ew
        if version in ewkey:
            if found:
                log.die('Multiple versions matching ' +
                        version_ + ': ' + found.key + ', ' + ew.key)
            found = ew
    return found


def getlist(pat):
    ret = []
    for ew in installations.values():
        if re.search(pat, ew.key, re.I):
            ret.append(ew)
    ret.sort(key=lambda ew: ew.key)
    return ret


def _make_unique(key):
    key = _shortname(key)
    if key not in installations:
        return key
    for i in range(1, 1000):
        trykey = key + ' (' + str(i) + ')'
        if trykey not in installations:
            return trykey
    log.die('could not get key')


def _handle_ewkey(subkey, subenumkey, ewkey_):
    dr = winreg.QueryValueEx(subkey, 'InstallLocation')[0].strip()
    p = 'HKEY_LOCAL_MACHINE\\' + REG_PATH + '\\' + str(subenumkey)
    ew = EwInst(ewkey_, dr, p)
    for sn in range(1000):
        try:
            v = winreg.EnumValue(subkey, sn)
            ew.set_attr(v[0], v[1])
        except OSError:
            pass


def _handle_enumkey(key, subenumkey):
    try:
        with winreg.OpenKey(key, subenumkey) as subkey:
            publisher = winreg.QueryValueEx(subkey, 'Publisher')
            if publisher[0] == 'IAR Systems':
                ewkey = winreg.QueryValueEx(subkey, 'DisplayName')[0].strip()
                dv = winreg.QueryValueEx(subkey, 'DisplayVersion')[0].strip()
                if dv not in ewkey:
                    ewkey += ' ' + dv
                if 'Workbench' in ewkey and 'Library' not in ewkey:
                    _handle_ewkey(subkey, subenumkey, ewkey)
    except OSError:
        pass


def add_from_reg():
    access_registry = winreg.ConnectRegistry(None, winreg.HKEY_LOCAL_MACHINE)
    with winreg.OpenKey(access_registry, REG_PATH) as key:
        for n in range(1000):
            try:
                _handle_enumkey(key, winreg.EnumKey(key, n))
            except OSError:
                break


def add_from_file(filename):
    if not os.path.isfile(filename):
        log.die('could not open ' + filename)

    cp = configparser.ConfigParser()
    cp.optionxform = str
    cp.read(filename)

    for sectname in cp.sections():
        sect = cp[sectname]
        ew = EwInst(sectname, sect['EW_DIR'], filename)
        for attr in sect:
            ew.set_attr(attr, sect[attr])


def _dump(f):
    frist = True
    for ew in installations.values():
        if not frist:
            f.write('\n')
        else:
            frist = False
        f.write(ew.get_info())


def dump(filename):
    if filename == '-':
        _dump(sys.stdout)
    else:
        with open(filename, 'w', encoding='utf-8') as f:
            _dump(f)
        print('\nWrote ' + filename + ' ... Done')


def _test(dr, subd):
    tk = find_tkdir(dr, subd)
    if not tk:
        return False
    inst = EwInst(os.path.basename(tk) + ' ' +
                  os.path.basename(dr), dr, 'scan', tk)
    inst.check()
    bn = os.path.basename(inst.toolkit_dir)
    has_ide = str(inst.ide_exe is not None)
    print(f'{dr}: tk={bn} ide={has_ide}')
    return True


def _search_dirs(root, dirs):
    found = 0
    test = False
    failed = []
    for d in dirs:
        sd = os.path.join(root, d) if root else d
        subd = listsubdirs(sd)
        r = _test(sd, subd) if subd else False
        if r:
            found += 1
            test = True
        else:
            r = _search_dirs(sd, subd)
            if r == 0:
                failed.append(sd)
            found += r

    # If at least one installation found, print sibblings without installation
    if test:
        for d in failed:
            log.debug('Note: No installations found in ' + d)

    return found


def scan(rootdirs):
    total = 0
    for d in rootdirs:
        r = _search_dirs(None, [d])
        total += r
        if r == 0:
            print('Note: No installations found in ' + d)
    print('total: ' + str(total) + ' installations found')
    if cfg.out_file == '-':
        print()