vim-crosoft: scripts/vsutil.py comparison

comparison scripts/vsutil.py @ 9:4ba6df1b2f97

Add built-in properties to the solution environment before resolving items.

author	Ludovic Chabant <ludovic@chabant.com>
date	Thu, 24 Sep 2020 22:57:50 -0700
parents	ae0fb567f459
children	cfcac4ed7d21

comparison

equal deleted inserted replaced

-:d5ddd9ffaf11
+:4ba6df1b2f97
 ITEM_TYPE_NONE = 'None'
 ITEM_TYPE_SOURCE_FILES = (ITEM_TYPE_CPP_SRC, ITEM_TYPE_CPP_HDR,
 ITEM_TYPE_CS_SRC, ITEM_TYPE_NONE)
 # Known VS properties.
 PROP_CONFIGURATION_TYPE = 'ConfigurationType'
 PROP_NMAKE_PREPROCESSOR_DEFINITIONS = 'NMakePreprocessorDefinitions'
 PROP_NMAKE_INCLUDE_SEARCH_PATH = 'NMakeIncludeSearchPath'
 if not c:
 c = self.__class__(self.label)
 self.conditionals[condition] = c
 return c
-def resolve(self, env):
+def _resolve(self, env):
 """ Resolves this group by evaluating each conditional sub-group
 based on the given build environment. Returns a 'flattened'
 version of ourselves.
 """
 c = self.__class__(self.label)
 def __init__(self, include, itemtype=None):
 self.include = include
 self.itemtype = itemtype
 self.metadata = {}
-def resolve(self, env):
+def _resolve(self, env):
-c = VSProjectItem(_resolve_value(self.include), self.itemtype)
+c = VSProjectItem(_resolve_value(self.include, env), self.itemtype)
 c.metadata = {k: _resolve_value(v, env)
 for k, v in self.metadata.items()}
 return c
 def __str__(self):
 self.items = []
 def get_source_items(self):
 return self.get_items_of_types(ITEM_TYPE_SOURCE_FILES)
-def get_items_of_types(self, *itemtypes):
+def get_items_of_type(self, itemtype):
-typeset = set(*itemtypes)
+for i in self.items:
+if i.itemtype == itemtype:
+yield i
+def get_items_of_types(self, itemtypes):
+typeset = set(itemtypes)
 for i in self.items:
 if i.itemtype in typeset:
 yield i
 def _collapse_child(self, child, env):
-self.items += [i.resolve(env) for i in child.items]
+self.items += [i._resolve(env) for i in child.items]
 class VSProjectProperty:
 """ A VS project property, like an include path or compiler flag. """
 def __init__(self, name, value):
 self.name = name
 self.value = value
-def resolve(self, env):
+def _resolve(self, env):
 c = VSProjectProperty(self.name, _resolve_value(self.value, env))
 return c
 def __str__(self):
 return "%s=%s" % (self.name, self.value)
 if p.name == propname:
 return p.value
 raise IndexError()
 def _collapse_child(self, child, env):
-self.properties += [p.resolve(env) for p in child.properties]
+self.properties += [p._resolve(env) for p in child.properties]
 class VSProject:
 """ A VS project. """
-def __init__(self, projtype, name, path, guid):
+def __init__(self, owner, projtype, name, path, guid):
+self.owner = owner
 self.type = projtype
 self.name = name
 self.path = path
 self.guid = guid
 self._itemgroups = None
 def itemgroup(self, label, resolved_with=None):
 self._ensure_loaded()
 ig = self._itemgroups.get(label)
 if resolved_with is not None and ig is not None:
 logger.debug("Resolving item group '%s'." % ig.label)
-ig = ig.resolve(resolved_with)
+self._validate_build_env(resolved_with)
+ig = ig._resolve(resolved_with)
 return ig
 def defaultitemgroup(self, resolved_with=None):
 return self.itemgroup(None, resolved_with=resolved_with)
 def propertygroup(self, label, resolved_with=None):
 self._ensure_loaded()
 pg = self._propgroups.get(label)
 if resolved_with is not None and pg is not None:
 logger.debug("Resolving property group '%s'." % pg.label)
-pg = pg.resolve(resolved_with)
+self._validate_build_env(resolved_with)
+pg = pg._resolve(resolved_with)
 return pg
 def defaultpropertygroup(self, resolved_with=None):
 return self.propertygroup(None, resolved_with=resolved_with)
 def get_abs_item_include(self, item):
 return os.path.abspath(os.path.join(self.absdirpath, item.include))
 def resolve(self, env):
 self._ensure_loaded()
+self._validate_build_env(env)
 propgroups = list(self._propgroups)
 itemgroups = list(self._itemgroups)
 self._propgroups[:] = []
 self._itemgroups[:] = []
 for pg in propgroups:
-rpg = pg.resolve(env)
+rpg = pg._resolve(env)
 self._propgroups.append(rpg)
 for ig in itemgroups:
-rig = ig.resolve(env)
+rig = ig._resolve(env)
 self._itemgroups.append(rig)
+def _validate_build_env(self, buildenv):
+buildenv['SolutionDir'] = self.owner.dirpath + os.path.sep
+buildenv['ProjectDir'] = self.absdirpath + os.path.sep
 def _ensure_loaded(self):
 if self._itemgroups is None or self._propgroups is None:
 self._load()
 m = _re_sln_project_decl_start.search(line)
 if m:
 # Found the start of a project declaration.
 try:
 p = VSProject(
+slnobj,
 m.group('type'), m.group('name'), m.group('path'),
 m.group('guid'))
 except:
 raise Exception(f"Error line {i}: unexpected project syntax.")
 logging.debug(f"  Adding project {p.name}")
 class SolutionCache:
 """ A class that contains a VS solution object, along with pre-indexed
 lists of items. It's meant to be saved on disk.
 """
-VERSION = 3
+VERSION = 4
 def __init__(self, slnobj):
 self.slnobj = slnobj
 self.index = None
+self._saved_version = SolutionCache.VERSION
 def build_cache(self):
 self.index = {}
 for proj in self.slnobj.projects:
 if proj.is_folder:
 # file would have been touched). Let's load the cache.
 with open(cachepath, 'rb') as fp:
 cache = pickle.load(fp)
 # Check that the cache version is up-to-date with this code.
-loaded_ver = getattr(cache, 'VERSION')
+loaded_ver = getattr(cache, '_saved_version', 0)
 if loaded_ver != SolutionCache.VERSION:
-logger.debug(f"Cache was saved with older format: {cachepath}")
+logger.debug(f"Cache was saved with older format: {cachepath} "
+f"(got {loaded_ver}, expected {SolutionCache.VERSION})")
 return None
+logger.debug(f"Cache has correct version: {loaded_ver}")
 slnobj = cache.slnobj
 # Check that none of the project files in the solution are newer
 # than this cache.

Mercurial > vim-crosoft

comparison scripts/vsutil.py @ 9:4ba6df1b2f97