Remake
 All Classes Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
Functions
Rule resolution

Functions

static void substitute_pattern (std::string const &pat, string_list const &src, string_list &dst)
 
static rule_t find_generic_rule (std::string const &target)
 
static rule_t find_rule (std::string const &target)
 

Detailed Description

Function Documentation

static rule_t find_generic_rule ( std::string const &  target)
static

Find a generic rule matching target:

  • the one leading to shorter matches has priority,
  • among equivalent rules, the earliest one has priority.

Definition at line 1685 of file remake.cpp.

Referenced by find_rule().

1686 {
1687  size_t tlen = target.length(), plen = tlen + 1;
1688  rule_t rule;
1689  for (rule_list::const_iterator i = generic_rules.begin(),
1690  i_end = generic_rules.end(); i != i_end; ++i)
1691  {
1692  for (string_list::const_iterator j = i->targets.begin(),
1693  j_end = i->targets.end(); j != j_end; ++j)
1694  {
1695  size_t len = j->length();
1696  if (tlen < len) continue;
1697  if (plen <= tlen - (len - 1)) continue;
1698  size_t pos = j->find('%');
1699  if (pos == std::string::npos) continue;
1700  size_t len2 = len - (pos + 1);
1701  if (j->compare(0, pos, target, 0, pos) ||
1702  j->compare(pos + 1, len2, target, tlen - len2, len2))
1703  continue;
1704  plen = tlen - (len - 1);
1705  rule = rule_t();
1706  rule.stem = target.substr(pos, plen);
1707  rule.script = i->script;
1708  substitute_pattern(rule.stem, i->targets, rule.targets);
1709  substitute_pattern(rule.stem, i->deps, rule.deps);
1710  break;
1711  }
1712  }
1713  return rule;
1714 }
static rule_t find_rule ( std::string const &  target)
static

Find a specific rule matching target. Return a generic one otherwise. If there is both a specific rule with an empty script and a generic rule, the generic one is returned after adding the dependencies of the specific one.

Definition at line 1721 of file remake.cpp.

Referenced by start().

1722 {
1723  rule_map::const_iterator i = specific_rules.find(target),
1724  i_end = specific_rules.end();
1725  // If there is a specific rule with a script, return it.
1726  if (i != i_end && !i->second->script.empty()) return *i->second;
1727  rule_t grule = find_generic_rule(target);
1728  // If there is no generic rule, return the specific rule (no script), if any.
1729  if (grule.targets.empty())
1730  {
1731  if (i != i_end) return *i->second;
1732  return grule;
1733  }
1734  // Optimize the lookup when there is only one target (already looked up).
1735  if (grule.targets.size() == 1)
1736  {
1737  if (i == i_end) return grule;
1738  grule.deps.insert(grule.deps.end(),
1739  i->second->deps.begin(), i->second->deps.end());
1740  grule.vars.insert(grule.vars.end(),
1741  i->second->vars.begin(), i->second->vars.end());
1742  return grule;
1743  }
1744  // Add the dependencies of the specific rules of every target to the
1745  // generic rule. If any of those rules has a nonempty script, error out.
1746  for (string_list::const_iterator j = grule.targets.begin(),
1747  j_end = grule.targets.end(); j != j_end; ++j)
1748  {
1749  i = specific_rules.find(*j);
1750  if (i == i_end) continue;
1751  if (!i->second->script.empty()) return rule_t();
1752  grule.deps.insert(grule.deps.end(),
1753  i->second->deps.begin(), i->second->deps.end());
1754  grule.vars.insert(grule.vars.end(),
1755  i->second->vars.begin(), i->second->vars.end());
1756  }
1757  return grule;
1758 }
static void substitute_pattern ( std::string const &  pat,
string_list const &  src,
string_list dst 
)
static

Substitute a pattern into a list of strings.

Definition at line 1669 of file remake.cpp.

Referenced by find_generic_rule().

1670 {
1671  for (string_list::const_iterator i = src.begin(),
1672  i_end = src.end(); i != i_end; ++i)
1673  {
1674  size_t pos = i->find('%');
1675  if (pos == std::string::npos)dst.push_back(*i);
1676  else dst.push_back(i->substr(0, pos) + pat + i->substr(pos + 1));
1677  }
1678 }