Mario1159/verilator
1
0
Fork 0
forked from github/verilator
Code Pull Requests Releases 1 Activity

C++11: Favor auto, range for. No functional change intended.

Browse Source
This commit is contained in:
Wilson Snyder 2020-08-16 11:43:49 -04:00
parent 034737d2a8
commit ee9d6dd63f
77 changed files with 371 additions and 505 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

20
include/verilated.cpp
View File

@ -1639,12 +1639,12 @@ std::string VL_TO_STRING_W(int words, WDataInP obj) {
std::string VL_TOLOWER_NN(const std::string& ld) VL_MT_SAFE {
std::string out = ld;
for (std::string::iterator it = out.begin(); it != out.end(); ++it) *it = tolower(*it);
for (auto& cr : out) cr = tolower(cr);
return out;
}
std::string VL_TOUPPER_NN(const std::string& ld) VL_MT_SAFE {
std::string out = ld;
for (std::string::iterator it = out.begin(); it != out.end(); ++it) *it = toupper(*it);
for (auto& cr : out) cr = toupper(cr);
return out;
}
@ -1862,8 +1862,8 @@ void VlReadMem::setData(void* valuep, const std::string& rhs) {
QData shift = m_hex ? 4ULL : 1ULL;
bool innum = false;
// Shift value in
for (std::string::const_iterator it = rhs.begin(); it != rhs.end(); ++it) {
char c = tolower(*it);
for (const auto& i : rhs) {
char c = tolower(i);
int value = (c >= 'a' ? (c == 'x' ? VL_RAND_RESET_I(4) : (c - 'a' + 10)) : (c - '0'));
if (m_bits <= 8) {
CData* datap = reinterpret_cast<CData*>(valuep);
@ -2312,7 +2312,7 @@ static void removeCb(Verilated::VoidPCb cb, void* datap, VoidPCbList& cbs) {
cbs.remove(pair);
}
static void runCallbacks(VoidPCbList& cbs) VL_MT_SAFE {
for (VoidPCbList::iterator it = cbs.begin(); it != cbs.end(); ++it) { it->first(it->second); }
for (const auto& i : cbs) i.first(i.second);
}
void Verilated::addFlushCb(VoidPCb cb, void* datap) VL_MT_SAFE {
@ -2445,9 +2445,7 @@ void VerilatedImp::internalsDump() VL_MT_SAFE {
VL_PRINTF_MT("internalsDump:\n");
versionDump();
VL_PRINTF_MT(" Argv:");
for (ArgVec::const_iterator it = s_s.m_argVec.begin(); it != s_s.m_argVec.end(); ++it) {
VL_PRINTF_MT(" %s", it->c_str());
}
for (const auto& i : s_s.m_argVec) VL_PRINTF_MT(" %s", i.c_str());
VL_PRINTF_MT("\n");
scopesDump();
exportsDump();
@ -2675,7 +2673,7 @@ void VerilatedScope::varInsert(int finalize, const char* namep, void* datap, boo
// cppcheck-suppress unusedFunction // Used by applications
VerilatedVar* VerilatedScope::varFind(const char* namep) const VL_MT_SAFE_POSTINIT {
if (VL_LIKELY(m_varsp)) {
VerilatedVarNameMap::iterator it = m_varsp->find(namep);
const auto it = m_varsp->find(namep);
if (VL_LIKELY(it != m_varsp->end())) return &(it->second);
}
return nullptr;
@ -2708,9 +2706,7 @@ void VerilatedScope::scopeDump() const {
}
}
if (VerilatedVarNameMap* varsp = this->varsp()) {
for (VerilatedVarNameMap::const_iterator it = varsp->begin(); it != varsp->end(); ++it) {
VL_PRINTF_MT(" VAR %p: %s\n", &(it->second), it->first);
}
for (const auto& i : *varsp) VL_PRINTF_MT(" VAR %p: %s\n", &(i.second), i.first);
}
}

27
include/verilated_cov.cpp
View File

@ -119,7 +119,7 @@ private:
// PRIVATE METHODS
int valueIndex(const std::string& value) VL_REQUIRES(m_mutex) {
static int nextIndex = KEY_UNDEF + 1;
ValueIndexMap::iterator iter = m_valueIndexes.find(value);
const auto iter = m_valueIndexes.find(value);
if (iter != m_valueIndexes.end()) return iter->second;
nextIndex++;
assert(nextIndex > 0); // Didn't rollover
@ -231,10 +231,7 @@ private:
#undef SELF_CHECK
}
void clearGuts() VL_REQUIRES(m_mutex) {
for (ItemList::const_iterator it = m_items.begin(); it != m_items.end(); ++it) {
VerilatedCovImpItem* itemp = *(it);
VL_DO_DANGLING(delete itemp, itemp);
}
for (const auto& itemp : m_items) VL_DO_DANGLING(delete itemp, itemp);
m_items.clear();
m_indexValues.clear();
m_valueIndexes.clear();
@ -252,8 +249,7 @@ public:
const VerilatedLockGuard lock(m_mutex);
if (matchp && matchp[0]) {
ItemList newlist;
for (ItemList::iterator it = m_items.begin(); it != m_items.end(); ++it) {
VerilatedCovImpItem* itemp = *(it);
for (const auto& itemp : m_items) {
if (!itemMatchesString(itemp, matchp)) {
VL_DO_DANGLING(delete itemp, itemp);
} else {
@ -266,9 +262,7 @@ public:
void zero() VL_EXCLUDES(m_mutex) {
Verilated::quiesce();
const VerilatedLockGuard lock(m_mutex);
for (ItemList::const_iterator it = m_items.begin(); it != m_items.end(); ++it) {
(*it)->zero();
}
for (const auto& itemp : m_items) itemp->zero();
}
// We assume there's always call to i/f/p in that order
@ -358,8 +352,7 @@ public:
// Build list of events; totalize if collapsing hierarchy
typedef std::map<std::string, std::pair<std::string, vluint64_t>> EventMap;
EventMap eventCounts;
for (ItemList::iterator it = m_items.begin(); it != m_items.end(); ++it) {
VerilatedCovImpItem* itemp = *(it);
for (const auto& itemp : m_items) {
std::string name;
std::string hier;
bool per_instance = false;
@ -390,7 +383,7 @@ public:
// inefficient)
// Find or insert the named event
EventMap::iterator cit = eventCounts.find(name);
const auto cit = eventCounts.find(name);
if (cit != eventCounts.end()) {
const std::string& oldhier = cit->second.first;
cit->second.second += itemp->count();
@ -401,11 +394,11 @@ public:
}
// Output body
for (EventMap::const_iterator it = eventCounts.begin(); it != eventCounts.end(); ++it) {
for (const auto& i : eventCounts) {
os << "C '" << std::dec;
os << it->first;
if (!it->second.first.empty()) os << keyValueFormatter(VL_CIK_HIER, it->second.first);
os << "' " << it->second.second;
os << i.first;
if (!i.second.first.empty()) os << keyValueFormatter(VL_CIK_HIER, i.second.first);
os << "' " << i.second.second;
os << std::endl;
}
}

13
include/verilated_fst_c.cpp
View File

@ -80,7 +80,7 @@ void VerilatedFst::open(const char* filename) VL_MT_UNSAFE {
VerilatedTrace<VerilatedFst>::traceInit();
// Clear the scope stack
std::list<std::string>::iterator it = m_curScope.begin();
auto it = m_curScope.begin();
while (it != m_curScope.end()) {
fstWriterSetUpscope(m_fst);
it = m_curScope.erase(it);
@ -89,10 +89,7 @@ void VerilatedFst::open(const char* filename) VL_MT_UNSAFE {
// convert m_code2symbol into an array for fast lookup
if (!m_symbolp) {
m_symbolp = new fstHandle[nextCode()];
for (Code2SymbolType::iterator it = m_code2symbol.begin(); it != m_code2symbol.end();
++it) {
m_symbolp[it->first] = it->second;
}
for (const auto& i : m_code2symbol) m_symbolp[i.first] = i.second;
}
m_code2symbol.clear();
@ -140,8 +137,8 @@ void VerilatedFst::declare(vluint32_t code, const char* name, int dtypenum, fstV
tokens.insert(tokens.begin(), moduleName()); // Add current module to the hierarchy
// Find point where current and new scope diverge
std::list<std::string>::iterator cur_it = m_curScope.begin();
std::list<std::string>::iterator new_it = tokens.begin();
auto cur_it = m_curScope.begin();
auto new_it = tokens.begin();
while (cur_it != m_curScope.end() && new_it != tokens.end()) {
if (*cur_it != *new_it) break;
++cur_it;
@ -171,7 +168,7 @@ void VerilatedFst::declare(vluint32_t code, const char* name, int dtypenum, fstV
fstWriterEmitEnumTableRef(m_fst, enumNum);
}
Code2SymbolType::const_iterator it = m_code2symbol.find(code);
const auto it = vlstd::as_const(m_code2symbol).find(code);
if (it == m_code2symbol.end()) { // New
m_code2symbol[code]
= fstWriterCreateVar(m_fst, vartype, vardir, bits, name_str.c_str(), 0);

27
include/verilated_heavy.h
View File

@ -145,21 +145,21 @@ public:
int exists(const T_Key& index) const { return m_map.find(index) != m_map.end(); }
// Return first element. Verilog: function int first(ref index);
int first(T_Key& indexr) const {
typename Map::const_iterator it = m_map.begin();
const auto it = m_map.cbegin();
if (it == m_map.end()) return 0;
indexr = it->first;
return 1;
}
// Return last element. Verilog: function int last(ref index)
int last(T_Key& indexr) const {
typename Map::const_reverse_iterator it = m_map.rbegin();
const auto it = m_map.crbegin();
if (it == m_map.rend()) return 0;
indexr = it->first;
return 1;
}
// Return next element. Verilog: function int next(ref index)
int next(T_Key& indexr) const {
typename Map::const_iterator it = m_map.find(indexr);
auto it = m_map.find(indexr);
if (VL_UNLIKELY(it == m_map.end())) return 0;
++it;
if (VL_UNLIKELY(it == m_map.end())) return 0;
@ -168,7 +168,7 @@ public:
}
// Return prev element. Verilog: function int prev(ref index)
int prev(T_Key& indexr) const {
typename Map::const_iterator it = m_map.find(indexr);
auto it = m_map.find(indexr);
if (VL_UNLIKELY(it == m_map.end())) return 0;
if (VL_UNLIKELY(it == m_map.begin())) return 0;
--it;
@ -179,7 +179,7 @@ public:
// Can't just overload operator[] or provide a "at" reference to set,
// because we need to be able to insert only when the value is set
T_Value& at(const T_Key& index) {
typename Map::iterator it = m_map.find(index);
const auto it = m_map.find(index);
if (it == m_map.end()) {
std::pair<typename Map::iterator, bool> pit
= m_map.insert(std::make_pair(index, m_defaultValue));
@ -189,7 +189,7 @@ public:
}
// Accessing. Verilog: v = assoc[index]
const T_Value& at(const T_Key& index) const {
typename Map::iterator it = m_map.find(index);
const auto it = m_map.find(index);
if (it == m_map.end()) {
return m_defaultValue;
} else {
@ -204,8 +204,8 @@ public:
std::string to_string() const {
std::string out = "'{";
std::string comma;
for (typename Map::const_iterator it = m_map.begin(); it != m_map.end(); ++it) {
out += comma + VL_TO_STRING(it->first) + ":" + VL_TO_STRING(it->second);
for (const auto& i : m_map) {
out += comma + VL_TO_STRING(i.first) + ":" + VL_TO_STRING(i.second);
comma = ", ";
}
// Default not printed - maybe random init data
@ -239,10 +239,9 @@ void VL_WRITEMEM_N(bool hex, int bits, const std::string& filename,
const VlAssocArray<T_Key, T_Value>& obj, QData start, QData end) VL_MT_SAFE {
VlWriteMem wmem(hex, bits, filename, start, end);
if (VL_UNLIKELY(!wmem.isOpen())) return;
for (typename VlAssocArray<T_Key, T_Value>::const_iterator it = obj.begin(); it != obj.end();
++it) {
QData addr = it->first;
if (addr >= start && addr <= end) wmem.print(addr, true, &(it->second));
for (const auto& i : obj) {
QData addr = i.first;
if (addr >= start && addr <= end) wmem.print(addr, true, &(i.second));
}
}
@ -361,8 +360,8 @@ public:
std::string to_string() const {
std::string out = "'{";
std::string comma;
for (typename Deque::const_iterator it = m_deque.begin(); it != m_deque.end(); ++it) {
out += comma + VL_TO_STRING(*it);
for (const auto& i : m_deque) {
out += comma + VL_TO_STRING(i);
comma = ", ";
}
return out + "} ";

55
include/verilated_imp.h
View File

@ -112,7 +112,7 @@ public:
// Unfortunately to release the lock we need to copy the message
// (Or have the message be a pointer, but then new/delete cost on each message)
// We assume messages are small, so copy
auto it = m_queue.begin();
const auto it = m_queue.begin();
const VerilatedMsg msg = *(it);
m_queue.erase(it);
m_mutex.unlock();
@ -284,9 +284,9 @@ public:
"%Error: Verilog called $test$plusargs or $value$plusargs without"
" testbench C first calling Verilated::commandArgs(argc,argv).");
}
for (ArgVec::const_iterator it = s_s.m_argVec.begin(); it != s_s.m_argVec.end(); ++it) {
if ((*it)[0] == '+') {
if (0 == strncmp(prefixp, it->c_str() + 1, len)) return *it;
for (const auto& i : s_s.m_argVec) {
if (i[0] == '+') {
if (0 == strncmp(prefixp, i.c_str() + 1, len)) return i;
}
}
return "";
@ -305,7 +305,7 @@ public:
// per map overhead * N scopes would take much more space and cache thrashing.
static inline void userInsert(const void* scopep, void* userKey, void* userData) VL_MT_SAFE {
const VerilatedLockGuard lock(s_s.m_userMapMutex);
UserMap::iterator it = s_s.m_userMap.find(std::make_pair(scopep, userKey));
const auto it = s_s.m_userMap.find(std::make_pair(scopep, userKey));
if (it != s_s.m_userMap.end()) {
it->second = userData;
} else {
@ -314,7 +314,7 @@ public:
}
static inline void* userFind(const void* scopep, void* userKey) VL_MT_SAFE {
const VerilatedLockGuard lock(s_s.m_userMapMutex);
UserMap::const_iterator it = s_s.m_userMap.find(std::make_pair(scopep, userKey));
const auto& it = vlstd::as_const(s_s.m_userMap).find(std::make_pair(scopep, userKey));
if (VL_UNLIKELY(it == s_s.m_userMap.end())) return nullptr;
return it->second;
}
@ -324,7 +324,7 @@ private:
static void userEraseScope(const VerilatedScope* scopep) VL_MT_SAFE {
// Slow ok - called once/scope on destruction, so we simply iterate.
const VerilatedLockGuard lock(s_s.m_userMapMutex);
for (UserMap::iterator it = s_s.m_userMap.begin(); it != s_s.m_userMap.end();) {
for (auto it = s_s.m_userMap.begin(); it != s_s.m_userMap.end();) {
if (it->first.first == scopep) {
s_s.m_userMap.erase(it++);
} else {
@ -335,13 +335,13 @@ private:
static void userDump() VL_MT_SAFE {
const VerilatedLockGuard lock(s_s.m_userMapMutex); // Avoid it changing in middle of dump
bool first = true;
for (UserMap::const_iterator it = s_s.m_userMap.begin(); it != s_s.m_userMap.end(); ++it) {
for (const auto& i : s_s.m_userMap) {
if (first) {
VL_PRINTF_MT(" userDump:\n");
first = false;
}
VL_PRINTF_MT(" DPI_USER_DATA scope %p key %p: %p\n", it->first.first,
it->first.second, it->second);
VL_PRINTF_MT(" DPI_USER_DATA scope %p key %p: %p\n", i.first.first, i.first.second,
i.second);
}
}
@ -350,7 +350,7 @@ public: // But only for verilated*.cpp
static void scopeInsert(const VerilatedScope* scopep) VL_MT_SAFE {
// Slow ok - called once/scope at construction
const VerilatedLockGuard lock(s_s.m_nameMutex);
VerilatedScopeNameMap::iterator it = s_s.m_nameMap.find(scopep->name());
const auto it = s_s.m_nameMap.find(scopep->name());
if (it == s_s.m_nameMap.end()) {
s_s.m_nameMap.insert(it, std::make_pair(scopep->name(), scopep));
}
@ -358,7 +358,7 @@ public: // But only for verilated*.cpp
static inline const VerilatedScope* scopeFind(const char* namep) VL_MT_SAFE {
const VerilatedLockGuard lock(s_s.m_nameMutex);
// If too slow, can assume this is only VL_MT_SAFE_POSINIT
VerilatedScopeNameMap::const_iterator it = s_s.m_nameMap.find(namep);
const auto& it = s_s.m_nameMap.find(namep);
if (VL_UNLIKELY(it == s_s.m_nameMap.end())) return nullptr;
return it->second;
}
@ -366,15 +366,14 @@ public: // But only for verilated*.cpp
// Slow ok - called once/scope at destruction
const VerilatedLockGuard lock(s_s.m_nameMutex);
userEraseScope(scopep);
VerilatedScopeNameMap::iterator it = s_s.m_nameMap.find(scopep->name());
const auto it = s_s.m_nameMap.find(scopep->name());
if (it != s_s.m_nameMap.end()) s_s.m_nameMap.erase(it);
}
static void scopesDump() VL_MT_SAFE {
const VerilatedLockGuard lock(s_s.m_nameMutex);
VL_PRINTF_MT(" scopesDump:\n");
for (VerilatedScopeNameMap::const_iterator it = s_s.m_nameMap.begin();
it != s_s.m_nameMap.end(); ++it) {
const VerilatedScope* scopep = it->second;
for (const auto& i : s_s.m_nameMap) {
const VerilatedScope* scopep = i.second;
scopep->scopeDump();
}
VL_PRINTF_MT("\n");
@ -408,7 +407,7 @@ public: // But only for verilated*.cpp
static int exportInsert(const char* namep) VL_MT_SAFE {
// Slow ok - called once/function at creation
const VerilatedLockGuard lock(s_s.m_exportMutex);
ExportNameMap::iterator it = s_s.m_exportMap.find(namep);
const auto it = s_s.m_exportMap.find(namep);
if (it == s_s.m_exportMap.end()) {
s_s.m_exportMap.insert(it, std::make_pair(namep, s_s.m_exportNext++));
return s_s.m_exportNext++;
@ -418,7 +417,7 @@ public: // But only for verilated*.cpp
}
static int exportFind(const char* namep) VL_MT_SAFE {
const VerilatedLockGuard lock(s_s.m_exportMutex);
ExportNameMap::const_iterator it = s_s.m_exportMap.find(namep);
const auto& it = s_s.m_exportMap.find(namep);
if (VL_LIKELY(it != s_s.m_exportMap.end())) return it->second;
std::string msg = (std::string("%Error: Testbench C called ") + namep
+ " but no such DPI export function name exists in ANY model");
@ -428,22 +427,20 @@ public: // But only for verilated*.cpp
static const char* exportName(int funcnum) VL_MT_SAFE {
// Slowpath; find name for given export; errors only so no map to reverse-map it
const VerilatedLockGuard lock(s_s.m_exportMutex);
for (ExportNameMap::const_iterator it = s_s.m_exportMap.begin();
it != s_s.m_exportMap.end(); ++it) {
if (it->second == funcnum) return it->first;
for (const auto& i : s_s.m_exportMap) {
if (i.second == funcnum) return i.first;
}
return "*UNKNOWN*";
}
static void exportsDump() VL_MT_SAFE {
const VerilatedLockGuard lock(s_s.m_exportMutex);
bool first = true;
for (ExportNameMap::const_iterator it = s_s.m_exportMap.begin();
it != s_s.m_exportMap.end(); ++it) {
for (const auto& i : s_s.m_exportMap) {
if (first) {
VL_PRINTF_MT(" exportDump:\n");
first = false;
}
VL_PRINTF_MT(" DPI_EXPORT_NAME %05d: %s\n", it->second, it->first);
VL_PRINTF_MT(" DPI_EXPORT_NAME %05d: %s\n", i.second, i.first);
}
}
// We don't free up m_exportMap until the end, because we can't be sure
@ -500,9 +497,7 @@ public: // But only for verilated*.cpp
static void fdFlush(IData fdi) VL_MT_SAFE {
const VerilatedLockGuard lock(s_s.m_fdMutex);
const VerilatedFpList fdlist = fdToFpList(fdi);
for (VerilatedFpList::const_iterator it = fdlist.begin(); it != fdlist.end(); ++it) {
fflush(*it);
}
for (const auto& i : fdlist) fflush(i);
}
static IData fdSeek(IData fdi, IData offset, IData origin) VL_MT_SAFE {
const VerilatedLockGuard lock(s_s.m_fdMutex);
@ -520,9 +515,9 @@ public: // But only for verilated*.cpp
static void fdWrite(IData fdi, const std::string& output) VL_MT_SAFE {
const VerilatedLockGuard lock(s_s.m_fdMutex);
const VerilatedFpList fdlist = fdToFpList(fdi);
for (VerilatedFpList::const_iterator it = fdlist.begin(); it != fdlist.end(); ++it) {
if (VL_UNLIKELY(!*it)) continue;
fwrite(output.c_str(), 1, output.size(), *it);
for (const auto& i : fdlist) {
if (VL_UNLIKELY(!i)) continue;
fwrite(output.c_str(), 1, output.size(), i);
}
}
static void fdClose(IData fdi) VL_MT_SAFE {

7
include/verilated_save.h
View File

@ -252,10 +252,9 @@ VerilatedSerialize& operator<<(VerilatedSerialize& os, VlAssocArray<T_Key, T_Val
os << rhs.atDefault();
vluint32_t len = rhs.size();
os << len;
for (typename VlAssocArray<T_Key, T_Value>::const_iterator it = rhs.begin(); it != rhs.end();
++it) {
T_Key index = it->first; // Copy to get around const_iterator
T_Value value = it->second;
for (const auto& i : rhs) {
T_Key index = i.first; // Copy to get around const_iterator
T_Value value = i.second;
os << index << value;
}
return os;

16
include/verilated_threads.cpp
View File

@ -125,9 +125,9 @@ void VlThreadPool::setupProfilingClientThread() {
void VlThreadPool::profileAppendAll(const VlProfileRec& rec) {
const VerilatedLockGuard lk(m_mutex);
for (ProfileSet::iterator it = m_allProfiles.begin(); it != m_allProfiles.end(); ++it) {
for (const auto& profilep : m_allProfiles) {
// Every thread's profile trace gets a copy of rec.
(*it)->emplace_back(rec);
profilep->emplace_back(rec);
}
}
@ -152,13 +152,12 @@ void VlThreadPool::profileDump(const char* filenamep, vluint64_t ticksElapsed) {
fprintf(fp, "VLPROF stat yields %" VL_PRI64 "u\n", VlMTaskVertex::yields());
vluint32_t thread_id = 0;
for (ProfileSet::const_iterator pit = m_allProfiles.begin(); pit != m_allProfiles.end();
++pit) {
for (const auto& pi : m_allProfiles) {
++thread_id;
bool printing = false; // False while in warmup phase
for (ProfileTrace::const_iterator eit = (*pit)->begin(); eit != (*pit)->end(); ++eit) {
switch (eit->m_type) {
for (const auto& ei : *pi) {
switch (ei.m_type) {
case VlProfileRec::TYPE_BARRIER: //
printing = true;
break;
@ -168,9 +167,8 @@ void VlThreadPool::profileDump(const char* filenamep, vluint64_t ticksElapsed) {
"VLPROF mtask %d"
" start %" VL_PRI64 "u end %" VL_PRI64 "u elapsed %" VL_PRI64 "u"
" predict_time %u cpu %u on thread %u\n",
eit->m_mtaskId, eit->m_startTime, eit->m_endTime,
(eit->m_endTime - eit->m_startTime), eit->m_predictTime, eit->m_cpu,
thread_id);
ei.m_mtaskId, ei.m_startTime, ei.m_endTime,
(ei.m_endTime - ei.m_startTime), ei.m_predictTime, ei.m_cpu, thread_id);
break;
default: assert(false); break; // LCOV_EXCL_LINE
}

16
include/verilated_vcd_c.cpp
View File

@ -185,15 +185,15 @@ void VerilatedVcd::makeNameMap() {
// If no scope was specified, prefix everything with a "top"
// This comes from user instantiations with no name - IE Vtop("").
bool nullScope = false;
for (NameMap::const_iterator it = m_namemapp->begin(); it != m_namemapp->end(); ++it) {
const std::string& hiername = it->first;
for (const auto& i : *m_namemapp) {
const std::string& hiername = i.first;
if (!hiername.empty() && hiername[0] == '\t') nullScope = true;
}
if (nullScope) {
NameMap* newmapp = new NameMap;
for (NameMap::const_iterator it = m_namemapp->begin(); it != m_namemapp->end(); ++it) {
const std::string& hiername = it->first;
const std::string& decl = it->second;
for (const auto& i : *m_namemapp) {
const std::string& hiername = i.first;
const std::string& decl = i.second;
std::string newname = std::string("top");
if (hiername[0] != '\t') newname += ' ';
newname += hiername;
@ -367,9 +367,9 @@ void VerilatedVcd::dumpHeader() {
// Print the signal names
const char* lastName = "";
for (NameMap::const_iterator it = m_namemapp->begin(); it != m_namemapp->end(); ++it) {
const std::string& hiernamestr = it->first;
const std::string& decl = it->second;
for (const auto& i : *m_namemapp) {
const std::string& hiernamestr = i.first;
const std::string& decl = i.second;
// Determine difference between the old and new names
const char* hiername = hiernamestr.c_str();

26
include/verilated_vpi.cpp
View File

@ -445,21 +445,21 @@ public:
VpioCbList& cbObjList = s_s.m_cbObjLists[cbp->reason()];
// We do not remove it now as we may be iterating the list,
// instead set to nullptr and will cleanup later
for (VpioCbList::iterator it = cbObjList.begin(); it != cbObjList.end(); ++it) {
if (*it == cbp) *it = nullptr;
for (auto& ir : cbObjList) {
if (ir == cbp) ir = nullptr;
}
}
static void cbTimedRemove(VerilatedVpioCb* cbp) {
VpioTimedCbs::iterator it = s_s.m_timedCbs.find(std::make_pair(cbp->time(), cbp));
if (VL_LIKELY(it != s_s.m_timedCbs.end())) { s_s.m_timedCbs.erase(it); }
const auto it = s_s.m_timedCbs.find(std::make_pair(cbp->time(), cbp));
if (VL_LIKELY(it != s_s.m_timedCbs.end())) s_s.m_timedCbs.erase(it);
}
static void callTimedCbs() VL_MT_UNSAFE_ONE {
assertOneCheck();
QData time = VL_TIME_Q();
for (VpioTimedCbs::iterator it = s_s.m_timedCbs.begin(); it != s_s.m_timedCbs.end();) {
for (auto it = s_s.m_timedCbs.begin(); it != s_s.m_timedCbs.end();) {
if (VL_UNLIKELY(it->first <= time)) {
VerilatedVpioCb* vop = it->second;
VpioTimedCbs::iterator last_it = it;
const auto last_it = it;
++it; // Timed callbacks are one-shot
s_s.m_timedCbs.erase(last_it);
VL_DEBUG_IF_PLI(VL_DBG_MSGF("- vpi: timed_callback %p\n", vop););
@ -470,14 +470,14 @@ public:
}
}
static QData cbNextDeadline() {
VpioTimedCbs::const_iterator it = s_s.m_timedCbs.begin();
if (VL_LIKELY(it != s_s.m_timedCbs.end())) return it->first;
const auto it = s_s.m_timedCbs.cbegin();
if (VL_LIKELY(it != s_s.m_timedCbs.cend())) return it->first;
return ~0ULL; // maxquad
}
static bool callCbs(vluint32_t reason) VL_MT_UNSAFE_ONE {
VpioCbList& cbObjList = s_s.m_cbObjLists[reason];
bool called = false;
for (VpioCbList::iterator it = cbObjList.begin(); it != cbObjList.end();) {
for (auto it = cbObjList.begin(); it != cbObjList.end();) {
if (VL_UNLIKELY(!*it)) { // Deleted earlier, cleanup
it = cbObjList.erase(it);
continue;
@ -494,7 +494,7 @@ public:
VpioCbList& cbObjList = s_s.m_cbObjLists[cbValueChange];
typedef std::set<VerilatedVpioVar*> VpioVarSet;
VpioVarSet update; // set of objects to update after callbacks
for (VpioCbList::iterator it = cbObjList.begin(); it != cbObjList.end();) {
for (auto it = cbObjList.begin(); it != cbObjList.end();) {
if (VL_UNLIKELY(!*it)) { // Deleted earlier, cleanup
it = cbObjList.erase(it);
continue;
@ -515,9 +515,7 @@ public:
}
}
}
for (VpioVarSet::const_iterator it = update.begin(); it != update.end(); ++it) {
memcpy((*it)->prevDatap(), (*it)->varDatap(), (*it)->entSize());
}
for (const auto& ip : update) { memcpy(ip->prevDatap(), ip->varDatap(), ip->entSize()); }
}
static VerilatedVpiError* error_info() VL_MT_UNSAFE_ONE; // getter for vpi error info
@ -1253,7 +1251,7 @@ vpiHandle vpi_iterate(PLI_INT32 type, vpiHandle object) {
VerilatedVpioModule* vop = VerilatedVpioModule::castp(object);
const VerilatedHierarchyMap* map = VerilatedImp::hierarchyMap();
const VerilatedScope* mod = vop ? vop->scopep() : nullptr;
VerilatedHierarchyMap::const_iterator it = map->find(const_cast<VerilatedScope*>(mod));
const auto it = vlstd::as_const(map)->find(const_cast<VerilatedScope*>(mod));
if (it == map->end()) return 0;
return ((new VerilatedVpioModuleIter(it->second))->castVpiHandle());
}

8
include/verilatedos.h
View File

@ -488,6 +488,14 @@ typedef unsigned long long vluint64_t; ///< 64-bit unsigned type
#define VL_STRINGIFY(x) VL_STRINGIFY2(x)
#define VL_STRINGIFY2(x) #x
//=========================================================================
// Conversions
namespace vlstd {
// C++17's std::as_const
template <class T> T const& as_const(T& v) { return v; }
}; // namespace vlstd
//=========================================================================
#endif // Guard

2
src/V3Active.cpp
View File

@ -109,7 +109,7 @@ public:
AstActive* activep = nullptr;
AstSenTree* activeSenp = m_activeSens.find(sensesp);
if (activeSenp) {
ActiveMap::iterator it = m_activeMap.find(activeSenp);
const auto it = m_activeMap.find(activeSenp);
UASSERT(it != m_activeMap.end(), "Corrupt active map");
activep = it->second;
}

4
src/V3Ast.cpp
View File

@ -1267,8 +1267,6 @@ AstNodeDType* AstNode::findVoidDType() const {
// AstNVisitor
void AstNVisitor::doDeletes() {
for (std::vector<AstNode*>::iterator it = m_deleteps.begin(); it != m_deleteps.end(); ++it) {
(*it)->deleteTree();
}
for (AstNode* nodep : m_deleteps) nodep->deleteTree();
m_deleteps.clear();
}

2
src/V3Ast.h
View File

@ -2464,7 +2464,7 @@ public:
void clearCache() { m_members.clear(); }
void repairMemberCache();
AstMemberDType* findMember(const string& name) const {
MemberNameMap::const_iterator it = m_members.find(name);
const auto it = m_members.find(name);
return (it == m_members.end()) ? nullptr : it->second;
}
static int lsb() { return 0; }

6
src/V3AstNodes.cpp
View File

@ -481,9 +481,9 @@ string AstVar::vlPropDecl(string propName) const {
out += "static const int " + propName + "__ulims[";
out += cvtToStr(ulims.size());
out += "] = {";
std::vector<int>::const_iterator it = ulims.begin();
auto it = ulims.cbegin();
out += cvtToStr(*it);
while (++it != ulims.end()) {
while (++it != ulims.cend()) {
out += ", ";
out += cvtToStr(*it);
}
@ -920,7 +920,7 @@ AstBasicDType* AstTypeTable::findInsertSameDType(AstBasicDType* nodep) {
VBasicTypeKey key(nodep->width(), nodep->widthMin(), nodep->numeric(), nodep->keyword(),
nodep->nrange());
DetailedMap& mapr = m_detailedMap;
DetailedMap::const_iterator it = mapr.find(key);
const auto it = mapr.find(key);
if (it != mapr.end()) return it->second;
mapr.insert(make_pair(key, nodep));
nodep->generic(true);

6
src/V3AstNodes.h
View File

@ -333,7 +333,7 @@ public:
void clearCache() { m_members.clear(); }
void repairCache();
AstNode* findMember(const string& name) const {
MemberNameMap::const_iterator it = m_members.find(name);
const auto it = m_members.find(name);
return (it == m_members.end()) ? nullptr : it->second;
}
bool isVirtual() const { return m_virtual; }
@ -4728,7 +4728,7 @@ public:
AstNode* addIndexValuep(uint32_t index, AstNode* newp) {
// Returns old value, caller must garbage collect
AstNode* oldp = nullptr;
KeyItemMap::iterator it = m_map.find(index);
const auto it = m_map.find(index);
if (it != m_map.end()) {
oldp = it->second->valuep();
it->second->valuep(newp);
@ -4740,7 +4740,7 @@ public:
return oldp;
}
AstNode* getIndexValuep(uint32_t index) const {
KeyItemMap::const_iterator it = m_map.find(index);
const auto it = m_map.find(index);
if (it == m_map.end()) {
return nullptr;
} else {

3
src/V3Branch.cpp
View File

@ -108,8 +108,7 @@ private:
// METHODS
void calc_tasks() {
for (CFuncVec::iterator it = m_cfuncsp.begin(); it != m_cfuncsp.end(); ++it) {
AstCFunc* nodep = *it;
for (AstCFunc* nodep : m_cfuncsp) {
if (!nodep->dontInline()) nodep->isInline(true);
}
}

16
src/V3Broken.cpp
View File

@ -54,7 +54,7 @@ public:
static void deleted(const AstNode* nodep) {
// Called by operator delete on any node - only if VL_LEAK_CHECKS
if (debug() >= 9) cout << "-nodeDel: " << cvtToHex(nodep) << endl;
NodeMap::iterator iter = s_nodes.find(nodep);
const auto iter = s_nodes.find(nodep);
UASSERT_OBJ(!(iter == s_nodes.end() || !(iter->second & FLAG_ALLOCATED)),
reinterpret_cast<const AstNode*>(nodep),
"Deleting AstNode object that was never tracked or already deleted");
@ -67,7 +67,7 @@ public:
static void addNewed(const AstNode* nodep) {
// Called by operator new on any node - only if VL_LEAK_CHECKS
if (debug() >= 9) cout << "-nodeNew: " << cvtToHex(nodep) << endl;
NodeMap::iterator iter = s_nodes.find(nodep);
const auto iter = s_nodes.find(nodep);
UASSERT_OBJ(!(iter != s_nodes.end() && (iter->second & FLAG_ALLOCATED)), nodep,
"Newing AstNode object that is already allocated");
if (iter == s_nodes.end()) {
@ -78,7 +78,7 @@ public:
static void setUnder(const AstNode* nodep, bool flag) {
// Called by BrokenCheckVisitor when each node entered/exited
if (!okIfLinkedTo(nodep)) return;
NodeMap::iterator iter = s_nodes.find(nodep);
const auto iter = s_nodes.find(nodep);
if (iter != s_nodes.end()) {
iter->second &= ~FLAG_UNDER_NOW;
if (flag) iter->second |= FLAG_UNDER_NOW;
@ -89,7 +89,7 @@ public:
// cppcheck-suppress knownConditionTrueFalse
if (!linkable) return; // save some time, else the map will get huge!
#endif
NodeMap::iterator iter = s_nodes.find(nodep);
const auto iter = s_nodes.find(nodep);
if (VL_UNCOVERABLE(iter == s_nodes.end())) {
#ifdef VL_LEAK_CHECKS
nodep->v3fatalSrc("AstNode is in tree, but not allocated");
@ -113,7 +113,7 @@ public:
// Some generic node has a pointer to this node. Is it allocated?
// Use this when might not be in tree; otherwise use okIfLinkedTo().
#ifdef VL_LEAK_CHECKS
NodeMap::iterator iter = s_nodes.find(nodep);
const auto iter = s_nodes.find(nodep);
if (iter == s_nodes.end()) return false;
if (!(iter->second & FLAG_ALLOCATED)) return false;
#endif
@ -121,7 +121,7 @@ public:
}
static bool okIfLinkedTo(const AstNode* nodep) {
// Some node in tree has a pointer to this node. Is it kosher?
NodeMap::iterator iter = s_nodes.find(nodep);
const auto iter = s_nodes.find(nodep);
if (iter == s_nodes.end()) return false;
#ifdef VL_LEAK_CHECKS
if (!(iter->second & FLAG_ALLOCATED)) return false;
@ -133,7 +133,7 @@ public:
static bool okIfAbove(const AstNode* nodep) {
// Must be linked to and below current node
if (!okIfLinkedTo(nodep)) return false;
NodeMap::iterator iter = s_nodes.find(nodep);
const auto iter = s_nodes.find(nodep);
if (iter == s_nodes.end()) return false;
if ((iter->second & FLAG_UNDER_NOW)) return false;
return true;
@ -141,7 +141,7 @@ public:
static bool okIfBelow(const AstNode* nodep) {
// Must be linked to and below current node
if (!okIfLinkedTo(nodep)) return false;
NodeMap::iterator iter = s_nodes.find(nodep);
const auto iter = s_nodes.find(nodep);
if (iter == s_nodes.end()) return false;
if (!(iter->second & FLAG_UNDER_NOW)) return false;
return true;

4
src/V3Cdc.cpp
View File

@ -543,9 +543,7 @@ private:
}
}
stable_sort(report.begin(), report.end());
for (std::deque<string>::iterator it = report.begin(); it != report.end(); ++it) {
*ofp << *it;
}
for (const auto& line : report) *ofp << line;
}
void edgeDomainRecurse(CdcEitherVertex* vertexp, bool traceDests, int level) {

4
src/V3Combine.cpp
View File

@ -108,8 +108,8 @@ public:
void deleteCall(AstCCall* nodep) {
std::pair<CallMmap::iterator, CallMmap::iterator> eqrange
= m_callMmap.equal_range(nodep->funcp());
for (CallMmap::iterator nextit = eqrange.first; nextit != eqrange.second;) {
CallMmap::iterator eqit = nextit++;
for (auto nextit = eqrange.first; nextit != eqrange.second;) {
const auto eqit = nextit++;
AstCCall* callp = eqit->second;
if (callp == nodep) {
m_callMmap.erase(eqit);

2
src/V3Config.cpp
View File

@ -60,7 +60,7 @@ public:
// Access an entity and resolve wildcards that match it
T* resolve(const string& name) {
// Lookup if it was resolved before, typically not
typename Map::iterator it = m_mapResolved.find(name);
auto it = m_mapResolved.find(name);
if (VL_UNLIKELY(it != m_mapResolved.end())) { return &it->second; }
T* newp = nullptr;

10
src/V3Const.cpp
View File

@ -1788,14 +1788,8 @@ private:
vec.push_back(senp);
}
stable_sort(vec.begin(), vec.end(), SenItemCmp());
for (std::vector<AstSenItem*>::iterator it = vec.begin(); it != vec.end();
++it) {
(*it)->unlinkFrBack();
}
for (std::vector<AstSenItem*>::iterator it = vec.begin(); it != vec.end();
++it) {
nodep->addSensesp(*it);
}
for (const auto& ip : vec) ip->unlinkFrBack();
for (const auto& ip : vec) nodep->addSensesp(ip);
break;
}
}

2
src/V3Coverage.cpp
View File

@ -140,7 +140,7 @@ private:
string traceNameForLine(AstNode* nodep, const string& type) {
string name = "vlCoverageLineTrace_" + nodep->fileline()->filebasenameNoExt() + "__"
+ cvtToStr(nodep->fileline()->lineno()) + "_" + type;
VarNameMap::iterator it = m_varnames.find(name);
const auto it = m_varnames.find(name);
if (it == m_varnames.end()) {
m_varnames.insert(make_pair(name, 1));
} else {

10
src/V3CoverageJoin.cpp
View File

@ -54,20 +54,16 @@ private:
// Note uses user4
V3Hashed hashed; // Duplicate code detection
// Hash all of the original signals we toggle cover
for (ToggleList::iterator it = m_toggleps.begin(); it != m_toggleps.end(); ++it) {
AstCoverToggle* nodep = *it;
hashed.hashAndInsert(nodep->origp());
}
for (AstCoverToggle* nodep : m_toggleps) hashed.hashAndInsert(nodep->origp());
// Find if there are any duplicates
for (ToggleList::iterator it = m_toggleps.begin(); it != m_toggleps.end(); ++it) {
AstCoverToggle* nodep = *it;
for (AstCoverToggle* nodep : m_toggleps) {
// nodep->backp() is null if we already detected it's a duplicate and unlinked it.
if (nodep->backp()) {
// Want to choose a base node, and keep finding duplicates that are identical.
// This prevents making chains where a->b, then c->d, then b->c, as we'll
// find a->b, a->c, a->d directly.
while (true) {
V3Hashed::iterator dupit = hashed.findDuplicate(nodep->origp());
const auto dupit = hashed.findDuplicate(nodep->origp());
if (dupit == hashed.end()) break;
//
AstNode* duporigp = hashed.iteratorNodep(dupit);

6
src/V3Dead.cpp
View File

@ -358,8 +358,7 @@ private:
}
void deadCheckCells() {
for (std::vector<AstCell*>::iterator it = m_cellsp.begin(); it != m_cellsp.end(); ++it) {
AstCell* cellp = *it;
for (AstCell* cellp : m_cellsp) {
if (cellp->user1() == 0 && !cellp->modp()->stmtsp()) {
cellp->modp()->user1Inc(-1);
VL_DO_DANGLING(cellp->unlinkFrBack()->deleteTree(), cellp);
@ -386,8 +385,7 @@ private:
void deadCheckVar() {
// Delete any unused varscopes
for (std::vector<AstVarScope*>::iterator it = m_vscsp.begin(); it != m_vscsp.end(); ++it) {
AstVarScope* vscp = *it;
for (AstVarScope* vscp : m_vscsp) {
if (vscp->user1() == 0) {
UINFO(4, " Dead " << vscp << endl);
std::pair<AssignMap::iterator, AssignMap::iterator> eqrange

2
src/V3Delayed.cpp
View File

@ -120,7 +120,7 @@ private:
AstVar* varp;
AstNodeModule* addmodp = oldvarscp->scopep()->modp();
// We need a new AstVar, but only one for all scopes, to match the new AstVarScope
VarMap::iterator it = m_modVarMap.find(make_pair(addmodp, name));
const auto it = m_modVarMap.find(make_pair(addmodp, name));
if (it != m_modVarMap.end()) {
// Created module's AstVar earlier under some other scope
varp = it->second;

4
src/V3Descope.cpp
View File

@ -148,7 +148,7 @@ private:
for (FuncMmap::iterator it = m_modFuncs.begin(); it != m_modFuncs.end(); ++it) {
string name = it->first;
AstCFunc* topFuncp = it->second;
FuncMmap::iterator nextIt1 = it;
auto nextIt1 = it;
++nextIt1;
bool moreOfSame1 = (nextIt1 != m_modFuncs.end() && nextIt1->first == name);
if (moreOfSame1) {
@ -171,7 +171,7 @@ private:
eachIt != m_modFuncs.end() && eachIt->first == name; ++eachIt) {
it = eachIt;
AstCFunc* funcp = eachIt->second;
FuncMmap::iterator nextIt2 = eachIt;
auto nextIt2 = eachIt;
++nextIt2;
bool moreOfSame = (nextIt2 != m_modFuncs.end() && nextIt2->first == name);
UASSERT_OBJ(funcp->scopep(), funcp, "Not scoped");

16
src/V3EmitC.cpp
View File

@ -226,8 +226,7 @@ public:
stable_sort(funcsp.begin(), funcsp.end(), CmpName());
for (FuncVec::iterator it = funcsp.begin(); it != funcsp.end(); ++it) {
const AstCFunc* funcp = *it;
for (const AstCFunc* funcp : funcsp) {
ofp()->putsPrivate(funcp->declPrivate());
if (!funcp->ifdef().empty()) puts("#ifdef " + funcp->ifdef() + "\n");
if (funcp->isStatic().trueUnknown()) puts("static ");
@ -1528,9 +1527,7 @@ class EmitCImp : EmitCStmts {
puts("QData __req = false; // Logically a bool\n"); // But not because it results in
// faster code
bool gotOne = false;
for (std::vector<AstChangeDet*>::iterator it = m_blkChangeDetVec.begin();
it != m_blkChangeDetVec.end(); ++it) {
AstChangeDet* changep = *it;
for (AstChangeDet* changep : m_blkChangeDetVec) {
if (changep->lhsp()) {
if (!gotOne) { // Not a clocked block
puts("__req |= (");
@ -1543,9 +1540,7 @@ class EmitCImp : EmitCStmts {
if (gotOne) puts(");\n");
if (gotOne && !v3Global.opt.protectIds()) {
// puts("VL_DEBUG_IF( if (__req) cout<<\"- CLOCKREQ );");
for (std::vector<AstChangeDet*>::iterator it = m_blkChangeDetVec.begin();
it != m_blkChangeDetVec.end(); ++it) {
AstChangeDet* nodep = *it;
for (AstChangeDet* nodep : m_blkChangeDetVec) {
if (nodep->lhsp()) {
puts("VL_DEBUG_IF( if(__req && (");
bool gotOneIgnore = false;
@ -1854,8 +1849,7 @@ void EmitCStmts::emitVarCtors(bool* firstp) {
ofp()->indentInc();
puts("\n");
puts("#if (SYSTEMC_VERSION>20011000)\n"); // SystemC 2.0.1 and newer
for (VarVec::iterator it = m_ctorVarsVec.begin(); it != m_ctorVarsVec.end(); ++it) {
const AstVar* varp = *it;
for (const AstVar* varp : m_ctorVarsVec) {
bool isArray = !VN_CAST(varp->dtypeSkipRefp(), BasicDType);
if (isArray) {
puts("// Skipping array: ");
@ -2887,7 +2881,7 @@ void EmitCStmts::emitSortedVarList(const VarVec& anons, const VarVec& nonanons,
}
if (anonL1s != 1)
puts("// Anonymous structures to workaround compiler member-count bugs\n");
VarVec::const_iterator it = anons.begin();
auto it = anons.cbegin();
for (int l3 = 0; l3 < anonL3s && it != anons.end(); ++l3) {
if (anonL3s != 1) puts("struct {\n");
for (int l2 = 0; l2 < anonL2s && it != anons.end(); ++l2) {

12
src/V3EmitCSyms.cpp
View File

@ -168,7 +168,7 @@ class EmitCSyms : EmitCBaseVisitor {
void varHierarchyScopes(string scp) {
while (!scp.empty()) {
ScopeNames::const_iterator scpit = m_vpiScopeCandidates.find(scp);
const auto scpit = m_vpiScopeCandidates.find(scp);
if ((scpit != m_vpiScopeCandidates.end())
&& (m_scopeNames.find(scp) == m_scopeNames.end())) {
m_scopeNames.insert(make_pair(scpit->second.m_symName, scpit->second));
@ -704,8 +704,8 @@ void EmitCSyms::emitSymImp() {
++lit) {
string fromname = scopeSymString(it->first);
string toname = scopeSymString(*lit);
ScopeNames::const_iterator from = m_scopeNames.find(fromname);
ScopeNames::const_iterator to = m_scopeNames.find(toname);
const auto from = vlstd::as_const(m_scopeNames).find(fromname);
const auto to = vlstd::as_const(m_scopeNames).find(toname);
UASSERT(from != m_scopeNames.end(), fromname + " not in m_scopeNames");
UASSERT(to != m_scopeNames.end(), toname + " not in m_scopeNames");
puts("__Vhier.add(");
@ -859,8 +859,7 @@ void EmitCSyms::emitDpiHdr() {
int firstExp = 0;
int firstImp = 0;
for (std::vector<AstCFunc*>::iterator it = m_dpis.begin(); it != m_dpis.end(); ++it) {
AstCFunc* nodep = *it;
for (AstCFunc* nodep : m_dpis) {
if (nodep->dpiExportWrapper()) {
if (!firstExp++) puts("\n// DPI EXPORTS\n");
puts("// DPI export" + ifNoProtect(" at " + nodep->fileline()->ascii()) + "\n");
@ -909,8 +908,7 @@ void EmitCSyms::emitDpiImp() {
puts("#include \"" + topClassName() + ".h\"\n");
puts("\n");
for (std::vector<AstCFunc*>::iterator it = m_dpis.begin(); it != m_dpis.end(); ++it) {
AstCFunc* nodep = *it;
for (AstCFunc* nodep : m_dpis) {
if (nodep->dpiExportWrapper()) {
puts("#ifndef _VL_DPIDECL_" + nodep->name() + "\n");
puts("#define _VL_DPIDECL_" + nodep->name() + "\n");

7
src/V3EmitMk.cpp
View File

@ -210,8 +210,7 @@ public:
of.puts("# User .cpp files (from .cpp's on Verilator command line)\n");
of.puts("VM_USER_CLASSES = \\\n");
const V3StringSet& cppFiles = v3Global.opt.cppFiles();
for (V3StringSet::const_iterator it = cppFiles.begin(); it != cppFiles.end(); ++it) {
string cppfile = *it;
for (const auto& cppfile : cppFiles) {
of.puts("\t" + V3Os::filenameNonExt(cppfile) + " \\\n");
string dir = V3Os::filenameDir(cppfile);
dirs.insert(dir);
@ -220,9 +219,7 @@ public:
of.puts("# User .cpp directories (from .cpp's on Verilator command line)\n");
of.puts("VM_USER_DIR = \\\n");
for (V3StringSet::iterator it = dirs.begin(); it != dirs.end(); ++it) {
of.puts("\t" + *it + " \\\n");
}
for (const auto& i : dirs) of.puts("\t" + i + " \\\n");
of.puts("\n");
of.puts("\n### Default rules...\n");

7
src/V3EmitXml.cpp
View File

@ -293,10 +293,9 @@ public:
nodep->accept(*this);
// Xml output
m_os << "<module_files>\n";
for (std::deque<FileLine*>::iterator it = m_nodeModules.begin(); it != m_nodeModules.end();
++it) {
m_os << "<file id=\"" << (*it)->filenameLetters() << "\" filename=\""
<< (*it)->filename() << "\" language=\"" << (*it)->language().ascii() << "\"/>\n";
for (const FileLine* ifp : m_nodeModules) {
m_os << "<file id=\"" << ifp->filenameLetters() << "\" filename=\"" << ifp->filename()
<< "\" language=\"" << ifp->language().ascii() << "\"/>\n";
}
m_os << "</module_files>\n";
}

25
src/V3File.cpp
View File

@ -149,26 +149,23 @@ inline void V3FileDependImp::writeDepend(const string& filename) {
const std::unique_ptr<std::ofstream> ofp(V3File::new_ofstream(filename));
if (ofp->fail()) v3fatal("Can't write " << filename);
for (std::set<DependFile>::iterator iter = m_filenameList.begin();
iter != m_filenameList.end(); ++iter) {
if (iter->target()) { *ofp << iter->filename() << " "; }
for (const DependFile& i : m_filenameList) {
if (i.target()) *ofp << i.filename() << " ";
}
*ofp << " : ";
*ofp << v3Global.opt.bin();
*ofp << " ";
for (std::set<DependFile>::iterator iter = m_filenameList.begin();
iter != m_filenameList.end(); ++iter) {
if (!iter->target()) { *ofp << iter->filename() << " "; }
for (const DependFile& i : m_filenameList) {
if (!i.target()) *ofp << i.filename() << " ";
}
*ofp << endl;
if (v3Global.opt.makePhony()) {
*ofp << endl;
for (std::set<DependFile>::iterator iter = m_filenameList.begin();
iter != m_filenameList.end(); ++iter) {
if (!iter->target()) { *ofp << iter->filename() << ":" << endl; }
for (const DependFile& i : m_filenameList) {
if (!i.target()) *ofp << i.filename() << ":" << endl;
}
}
}
@ -576,7 +573,7 @@ protected:
friend class VInFilter;
// Read file contents and return it
bool readWholefile(const string& filename, StrList& outl) {
FileContentsMap::iterator it = m_contentsMap.find(filename);
const auto it = m_contentsMap.find(filename);
if (it != m_contentsMap.end()) {
outl.push_back(it->second);
return true;
@ -592,12 +589,12 @@ protected:
}
size_t listSize(StrList& sl) {
size_t out = 0;
for (StrList::iterator it = sl.begin(); it != sl.end(); ++it) out += it->length();
for (const string& i : sl) out += i.length();
return out;
}
string listString(StrList& sl) {
string out;
for (StrList::iterator it = sl.begin(); it != sl.end(); ++it) out += *it;
for (const string& i : sl) out += i;
return out;
}
// CONSTRUCTORS
@ -984,7 +981,7 @@ public:
// METHODS
string passthru(const string& old) {
if (!v3Global.opt.protectIds()) return old;
IdMap::iterator it = m_nameMap.find(old);
const auto it = m_nameMap.find(old);
if (it != m_nameMap.end()) {
// No way to go back and correct the older crypt name
UASSERT(old == it->second,
@ -997,7 +994,7 @@ public:
}
string protectIf(const string& old, bool doIt) {
if (!v3Global.opt.protectIds() || old.empty() || !doIt) return old;
IdMap::iterator it = m_nameMap.find(old);
const auto it = m_nameMap.find(old);
if (it != m_nameMap.end())
return it->second;
else {

6
src/V3FileLine.cpp
View File

@ -58,7 +58,7 @@ string FileLineSingleton::filenameLetters(int fileno) {
//! We associate a language with each source file, so we also set the default
//! for this.
int FileLineSingleton::nameToNumber(const string& filename) {
FileNameNumMap::const_iterator it = m_namemap.find(filename);
const auto it = vlstd::as_const(m_namemap).find(filename);
if (VL_LIKELY(it != m_namemap.end())) return it->second;
int num = m_names.size();
m_names.push_back(filename);
@ -454,7 +454,7 @@ void* FileLine::operator new(size_t size) {
void FileLine::operator delete(void* objp, size_t size) {
if (!objp) return;
FileLine* flp = static_cast<FileLine*>(objp);
FileLineCheckSet::iterator it = fileLineLeakChecks.find(flp);
const auto it = fileLineLeakChecks.find(flp);
if (it != fileLineLeakChecks.end()) {
fileLineLeakChecks.erase(it);
} else {
@ -470,7 +470,7 @@ void FileLine::deleteAllRemaining() {
// that way. Unfortunately this makes our leak checking a big mess, so
// only when leak checking we'll track them all and cleanup.
while (true) {
FileLineCheckSet::iterator it = fileLineLeakChecks.begin();
const auto it = fileLineLeakChecks.begin();
if (it == fileLineLeakChecks.end()) break;
delete *it;
// Operator delete will remove the iterated object from the list.

4
src/V3Gate.cpp
View File

@ -983,8 +983,8 @@ public:
hash(extra1p);
hash(extra2p);
V3Hashed::iterator inserted = m_hashed.hashAndInsert(rhsp);
V3Hashed::iterator dupit = m_hashed.findDuplicate(rhsp, this);
const auto inserted = m_hashed.hashAndInsert(rhsp);
const auto dupit = m_hashed.findDuplicate(rhsp, this);
// Even though rhsp was just inserted, V3Hashed::findDuplicate doesn't
// return anything in the hash that has the same pointer (V3Hashed.cpp::findDuplicate)
// So dupit is either a different, duplicate rhsp, or the end of the hash.

2
src/V3Global.cpp
View File

@ -83,7 +83,7 @@ void V3Global::dumpCheckGlobalTree(const string& stagename, int newNumber, bool
}
const std::string& V3Global::ptrToId(const void* p) {
PtrToIdMap::iterator it = m_ptrToId.find(p);
auto it = m_ptrToId.find(p);
if (it == m_ptrToId.end()) {
std::ostringstream os;
if (p) {

10
src/V3GraphAcyc.cpp
View File

@ -189,10 +189,7 @@ public:
: m_origGraphp{origGraphp}
, m_origEdgeFuncp{edgeFuncp} {}
~GraphAcyc() {
for (std::vector<OrigEdgeList*>::iterator it = m_origEdgeDelp.begin();
it != m_origEdgeDelp.end(); ++it) {
delete (*it);
}
for (OrigEdgeList* ip : m_origEdgeDelp) delete ip;
m_origEdgeDelp.clear();
}
void main();
@ -476,10 +473,7 @@ void GraphAcyc::place() {
// Process each edge in weighted order
m_placeStep = 10;
for (std::vector<V3GraphEdge*>::iterator it = edges.begin(); it != edges.end(); ++it) {
V3GraphEdge* edgep = (*it);
placeTryEdge(edgep);
}
for (V3GraphEdge* edgep : edges) placeTryEdge(edgep);
}
void GraphAcyc::placeTryEdge(V3GraphEdge* edgep) {

4
src/V3GraphAlg.cpp
View File

@ -487,9 +487,7 @@ void V3Graph::sortVertices() {
}
std::stable_sort(vertices.begin(), vertices.end(), GraphSortVertexCmp());
this->verticesUnlink();
for (std::vector<V3GraphVertex*>::iterator it = vertices.begin(); it != vertices.end(); ++it) {
(*it)->verticesPushBack(this);
}
for (V3GraphVertex* ip : vertices) ip->verticesPushBack(this);
}
void V3Graph::sortEdges() {

2
src/V3GraphDfa.cpp
View File

@ -182,7 +182,7 @@ private:
// not depend on order of edges
uint32_t hash = hashDfaOrigins(nfasWithInput);
std::pair<HashMap::iterator, HashMap::iterator> eqrange = m_hashMap.equal_range(hash);
const auto eqrange = m_hashMap.equal_range(hash);
for (HashMap::iterator it = eqrange.first; it != eqrange.second; ++it) {
DfaVertex* testp = it->second;
if (compareDfaOrigins(nfasWithInput, testp)) {

4
src/V3GraphStream.h
View File

@ -197,7 +197,7 @@ private:
for (V3GraphEdge* edgep = vertexp->outBeginp(); edgep; edgep = edgep->outNextp()) {
V3GraphVertex* toVertexp = edgep->top();
typename WaitingVertices::iterator it = m_waitingVertices.find(toVertexp);
const auto it = m_waitingVertices.find(toVertexp);
UASSERT_OBJ(it != m_waitingVertices.end(), toVertexp,
"Found edge into vertex not in waiting list.");
if (it->second.unblock()) {
@ -209,7 +209,7 @@ private:
for (V3GraphEdge* edgep = vertexp->inBeginp(); edgep; edgep = edgep->inNextp()) {
V3GraphVertex* fromVertexp = edgep->fromp();
typename WaitingVertices::iterator it = m_waitingVertices.find(fromVertexp);
const auto it = m_waitingVertices.find(fromVertexp);
UASSERT_OBJ(it != m_waitingVertices.end(), fromVertexp,
"Found edge into vertex not in waiting list.");
if (it->second.unblock()) {

2
src/V3HierBlock.cpp
View File

@ -377,7 +377,7 @@ V3HierBlockPlan::HierVector V3HierBlockPlan::hierBlocksSorted() const {
for (V3HierBlock::HierBlockSet::const_iterator it = p.begin(); it != p.end(); ++it) {
// Delete hblockp from parrents. If a parent does not have a child anymore, then it is
// a leaf too.
const ChildrenMap::iterator parentIt = childrenOfHierBlock.find(*it);
const auto parentIt = childrenOfHierBlock.find(*it);
UASSERT_OBJ(parentIt != childrenOfHierBlock.end(), (*it)->modp(), "must be included");
const V3HierBlock::HierBlockSet::size_type erased = parentIt->second.erase(hblockp);
UASSERT_OBJ(erased == 1, hblockp->modp(),

2
src/V3Inline.cpp
View File

@ -174,7 +174,7 @@ private:
// Iterate through all modules in bottom-up order.
// Make a final inlining decision for each.
for (ModVec::reverse_iterator it = m_allMods.rbegin(); it != m_allMods.rend(); ++it) {
for (auto it = m_allMods.rbegin(); it != m_allMods.rend(); ++it) {
AstNodeModule* modp = *it;
// If we're going to inline some modules into this one,

2
src/V3Inst.cpp
View File

@ -164,7 +164,7 @@ public:
m_modVarNameMap.insert(make_pair(nodep->name(), nodep));
}
AstVar* find(const string& name) {
VarNameMap::iterator it = m_modVarNameMap.find(name);
const auto it = m_modVarNameMap.find(name);
if (it != m_modVarNameMap.end()) {
return it->second;
} else {

2
src/V3LanguageWords.h
View File

@ -41,7 +41,7 @@ public:
static const_iterator begin() { return s().s_kwdMap.begin(); }
static const_iterator end() { return s().s_kwdMap.end(); }
static string isKeyword(const string& kwd) {
KeywordMap::const_iterator it = s().s_kwdMap.find(kwd);
const auto it = vlstd::as_const(s().s_kwdMap).find(kwd);
if (it == s().s_kwdMap.end()) return "";
return it->second;
}

19
src/V3Life.cpp
View File

@ -55,10 +55,9 @@ public:
~LifeState() {
V3Stats::addStatSum("Optimizations, Lifetime assign deletions", m_statAssnDel);
V3Stats::addStatSum("Optimizations, Lifetime constant prop", m_statAssnCon);
for (std::vector<AstNode*>::iterator it = m_unlinkps.begin(); it != m_unlinkps.end();
++it) {
(*it)->unlinkFrBack();
(*it)->deleteTree();
for (AstNode* ip : m_unlinkps) {
ip->unlinkFrBack();
ip->deleteTree();
}
}
// METHODS
@ -168,7 +167,7 @@ public:
// Do we have a old assignment we can nuke?
UINFO(4, " ASSIGNof: " << nodep << endl);
UINFO(7, " new: " << assp << endl);
LifeMap::iterator it = m_map.find(nodep);
const auto it = m_map.find(nodep);
if (it != m_map.end()) {
checkRemoveAssign(it);
it->second.simpleAssign(assp);
@ -179,7 +178,7 @@ public:
}
void complexAssign(AstVarScope* nodep) {
UINFO(4, " clearof: " << nodep << endl);
LifeMap::iterator it = m_map.find(nodep);
const auto it = m_map.find(nodep);
if (it != m_map.end()) {
it->second.complexAssign();
} else {
@ -188,7 +187,7 @@ public:
}
void varUsageReplace(AstVarScope* nodep, AstVarRef* varrefp) {
// Variable rvalue. If it references a constant, we can simply replace it
LifeMap::iterator it = m_map.find(nodep);
const auto it = m_map.find(nodep);
if (it != m_map.end()) {
if (AstConst* constp = it->second.constNodep()) {
if (!varrefp->varp()->isSigPublic()) {
@ -208,7 +207,7 @@ public:
}
}
void complexAssignFind(AstVarScope* nodep) {
LifeMap::iterator it = m_map.find(nodep);
const auto it = m_map.find(nodep);
if (it != m_map.end()) {
UINFO(4, " casfind: " << it->first << endl);
it->second.complexAssign();
@ -217,7 +216,7 @@ public:
}
}
void consumedFind(AstVarScope* nodep) {
LifeMap::iterator it = m_map.find(nodep);
const auto it = m_map.find(nodep);
if (it != m_map.end()) {
it->second.consumed();
} else {
@ -254,7 +253,7 @@ public:
if (it->second.setBeforeUse() && nodep->user1()) {
// Both branches set the var, we can remove the assignment before the IF.
UINFO(4, "DUALBRANCH " << nodep << endl);
LifeMap::iterator itab = m_map.find(nodep);
const auto itab = m_map.find(nodep);
if (itab != m_map.end()) checkRemoveAssign(itab);
}
}

2
src/V3LinkCells.cpp
View File

@ -467,7 +467,7 @@ private:
void readModNames() {
// mangled_name, BlockOptions
const V3HierBlockOptSet& hierBlocks = v3Global.opt.hierBlocks();
V3HierBlockOptSet::const_iterator hierIt = hierBlocks.find(v3Global.opt.topModule());
const auto hierIt = vlstd::as_const(hierBlocks).find(v3Global.opt.topModule());
UASSERT((hierIt != hierBlocks.end()) == v3Global.opt.hierChild(),
"information of the top module must exist if --hierarchical-child is set");
// Look at all modules, and store pointers to all module names

10
src/V3LinkDot.cpp
View File

@ -396,7 +396,7 @@ public:
return symp;
}
VSymEnt* getScopeSym(AstScope* nodep) {
NameScopeSymMap::iterator it = m_nameScopeSymMap.find(nodep->name());
const auto it = m_nameScopeSymMap.find(nodep->name());
UASSERT_OBJ(it != m_nameScopeSymMap.end(), nodep,
"Scope never assigned a symbol entry '" << nodep->name() << "'");
return it->second;
@ -404,7 +404,7 @@ public:
void implicitOkAdd(AstNodeModule* nodep, const string& varname) {
// Mark the given variable name as being allowed to be implicitly declared
if (nodep) {
ImplicitNameSet::iterator it = m_implicitNameSet.find(make_pair(nodep, varname));
const auto it = m_implicitNameSet.find(make_pair(nodep, varname));
if (it == m_implicitNameSet.end()) {
m_implicitNameSet.insert(make_pair(nodep, varname));
}
@ -438,9 +438,7 @@ public:
return ifacerefp;
}
void computeIfaceVarSyms() {
for (IfaceVarSyms::iterator it = m_ifaceVarSyms.begin(); it != m_ifaceVarSyms.end();
++it) {
VSymEnt* varSymp = *it;
for (VSymEnt* varSymp : m_ifaceVarSyms) {
AstVar* varp = varSymp ? VN_CAST(varSymp->nodep(), Var) : nullptr;
UINFO(9, " insAllIface se" << cvtToHex(varSymp) << " " << varp << endl);
AstIfaceRefDType* ifacerefp = ifaceRefFromArray(varp->subDTypep());
@ -507,7 +505,7 @@ public:
VSymEnt* lhsp = it->first;
VSymEnt* srcp = lhsp;
while (true) { // Follow chain of aliases up to highest level non-alias
ScopeAliasMap::iterator it2 = m_scopeAliasMap[samn].find(srcp);
const auto it2 = m_scopeAliasMap[samn].find(srcp);
if (it2 != m_scopeAliasMap[samn].end()) {
srcp = it2->second;
continue;

3
src/V3LinkJump.cpp
View File

@ -255,8 +255,7 @@ private:
UINFO(8, " DISABLE " << nodep << endl);
iterateChildren(nodep);
AstNodeBlock* blockp = nullptr;
for (BlockStack::reverse_iterator it = m_blockStack.rbegin(); it != m_blockStack.rend();
++it) {
for (auto it = m_blockStack.rbegin(); it != m_blockStack.rend(); ++it) {
UINFO(9, " UNDERBLK " << *it << endl);
if ((*it)->name() == nodep->name()) {
blockp = *it;

3
src/V3Localize.cpp
View File

@ -118,8 +118,7 @@ private:
flags.setNodeFlags(nodep);
}
void moveVars() {
for (std::vector<AstVar*>::iterator it = m_varps.begin(); it != m_varps.end(); ++it) {
AstVar* nodep = *it;
for (AstVar* nodep : m_varps) {
if (nodep->valuep()) clearOptimizable(nodep, "HasInitValue");
if (!VarFlags(nodep).m_stdFuncAsn) clearStdOptimizable(nodep, "NoStdAssign");
VarFlags flags(nodep);

8
src/V3Number.cpp
View File

@ -567,8 +567,8 @@ string V3Number::displayed(AstNode* nodep, const string& vformat) const {
}
string V3Number::displayed(FileLine* fl, const string& vformat) const {
string::const_iterator pos = vformat.begin();
UASSERT(pos != vformat.end() && pos[0] == '%',
auto pos = vformat.cbegin();
UASSERT(pos != vformat.cend() && pos[0] == '%',
"$display-like function with non format argument " << *this);
++pos;
bool left = false;
@ -2400,14 +2400,14 @@ V3Number& V3Number::opToLowerN(const V3Number& lhs) {
NUM_ASSERT_OP_ARGS1(lhs);
NUM_ASSERT_STRING_ARGS1(lhs);
std::string out = lhs.toString();
for (std::string::iterator it = out.begin(); it != out.end(); ++it) { *it = tolower(*it); }
for (auto& cr : out) cr = tolower(cr);
return setString(out);
}
V3Number& V3Number::opToUpperN(const V3Number& lhs) {
NUM_ASSERT_OP_ARGS1(lhs);
NUM_ASSERT_STRING_ARGS1(lhs);
std::string out = lhs.toString();
for (std::string::iterator it = out.begin(); it != out.end(); ++it) { *it = toupper(*it); }
for (auto& cr : out) cr = toupper(cr);
return setString(out);
}

45
src/V3Options.cpp
View File

@ -469,7 +469,7 @@ string V3Options::fileExists(const string& filename) {
string dir = V3Os::filenameDir(filename);
string basename = V3Os::filenameNonDir(filename);
V3OptionsImp::DirMap::iterator diriter = m_impp->m_dirMap.find(dir);
auto diriter = m_impp->m_dirMap.find(dir);
if (diriter == m_impp->m_dirMap.end()) {
// Read the listing
m_impp->m_dirMap.insert(std::make_pair(dir, std::set<string>()));
@ -484,7 +484,7 @@ string V3Options::fileExists(const string& filename) {
}
// Find it
std::set<string>* filesetp = &(diriter->second);
std::set<string>::iterator fileiter = filesetp->find(basename);
const auto fileiter = filesetp->find(basename);
if (fileiter == filesetp->end()) {
return ""; // Not found
}
@ -495,9 +495,8 @@ string V3Options::fileExists(const string& filename) {
}
string V3Options::filePathCheckOneDir(const string& modname, const string& dirname) {
for (std::list<string>::iterator extIter = m_impp->m_libExtVs.begin();
extIter != m_impp->m_libExtVs.end(); ++extIter) {
string fn = V3Os::filenameFromDirBase(dirname, modname + *extIter);
for (const string& i : m_impp->m_libExtVs) {
string fn = V3Os::filenameFromDirBase(dirname, modname + i);
string exists = fileExists(fn);
if (exists != "") {
// Strip ./, it just looks ugly
@ -530,14 +529,12 @@ string V3Options::filePath(FileLine* fl, const string& modname, const string& la
// Find a filename to read the specified module name,
// using the incdir and libext's.
// Return "" if not found.
for (std::list<string>::iterator dirIter = m_impp->m_incDirUsers.begin();
dirIter != m_impp->m_incDirUsers.end(); ++dirIter) {
string exists = filePathCheckOneDir(modname, *dirIter);
for (const string& dir : m_impp->m_incDirUsers) {
string exists = filePathCheckOneDir(modname, dir);
if (exists != "") return exists;
}
for (std::list<string>::iterator dirIter = m_impp->m_incDirFallbacks.begin();
dirIter != m_impp->m_incDirFallbacks.end(); ++dirIter) {
string exists = filePathCheckOneDir(modname, *dirIter);
for (const string& dir : m_impp->m_incDirFallbacks) {
string exists = filePathCheckOneDir(modname, dir);
if (exists != "") return exists;
}
@ -568,19 +565,15 @@ void V3Options::filePathLookedMsg(FileLine* fl, const string& modname) {
<< endl);
}
std::cerr << V3Error::warnMore() << "... Looked in:" << endl;
for (std::list<string>::iterator dirIter = m_impp->m_incDirUsers.begin();
dirIter != m_impp->m_incDirUsers.end(); ++dirIter) {
for (std::list<string>::iterator extIter = m_impp->m_libExtVs.begin();
extIter != m_impp->m_libExtVs.end(); ++extIter) {
string fn = V3Os::filenameFromDirBase(*dirIter, modname + *extIter);
for (const string& dir : m_impp->m_incDirUsers) {
for (const string& ext : m_impp->m_libExtVs) {
string fn = V3Os::filenameFromDirBase(dir, modname + ext);
std::cerr << V3Error::warnMore() << " " << fn << endl;
}
}
for (std::list<string>::iterator dirIter = m_impp->m_incDirFallbacks.begin();
dirIter != m_impp->m_incDirFallbacks.end(); ++dirIter) {
for (std::list<string>::iterator extIter = m_impp->m_libExtVs.begin();
extIter != m_impp->m_libExtVs.end(); ++extIter) {
string fn = V3Os::filenameFromDirBase(*dirIter, modname + *extIter);
for (const string& dir : m_impp->m_incDirFallbacks) {
for (const string& ext : m_impp->m_libExtVs) {
string fn = V3Os::filenameFromDirBase(dir, modname + ext);
std::cerr << V3Error::warnMore() << " " << fn << endl;
}
}
@ -596,7 +589,7 @@ V3LangCode V3Options::fileLanguage(const string& filename) {
string::size_type pos;
if ((pos = ext.rfind('.')) != string::npos) {
ext.erase(0, pos + 1);
std::map<string, V3LangCode>::iterator it = m_impp->m_langExts.find(ext);
const auto it = m_impp->m_langExts.find(ext);
if (it != m_impp->m_langExts.end()) return it->second;
}
return m_defaultLanguage;
@ -1816,7 +1809,7 @@ void V3Options::setDebugMode(int level) {
}
void V3Options::setDebugSrcLevel(const string& srcfile, int level) {
DebugSrcMap::iterator iter = m_debugSrcs.find(srcfile);
const auto iter = m_debugSrcs.find(srcfile);
if (iter != m_debugSrcs.end()) {
iter->second = level;
} else {
@ -1828,7 +1821,7 @@ int V3Options::debugSrcLevel(const string& srcfile_path, int default_level) {
// For simplicity, calling functions can just use __FILE__ for srcfile.
// That means though we need to cleanup the filename from ../Foo.cpp -> Foo
string srcfile = V3Os::filenameNonDirExt(srcfile_path);
DebugSrcMap::iterator iter = m_debugSrcs.find(srcfile);
const auto iter = m_debugSrcs.find(srcfile);
if (iter != m_debugSrcs.end()) {
return iter->second;
} else {
@ -1837,7 +1830,7 @@ int V3Options::debugSrcLevel(const string& srcfile_path, int default_level) {
}
void V3Options::setDumpTreeLevel(const string& srcfile, int level) {
DebugSrcMap::iterator iter = m_dumpTrees.find(srcfile);
const auto iter = m_dumpTrees.find(srcfile);
if (iter != m_dumpTrees.end()) {
iter->second = level;
} else {
@ -1849,7 +1842,7 @@ int V3Options::dumpTreeLevel(const string& srcfile_path) {
// For simplicity, calling functions can just use __FILE__ for srcfile.
// That means though we need to cleanup the filename from ../Foo.cpp -> Foo
string srcfile = V3Os::filenameNonDirExt(srcfile_path);
DebugSrcMap::iterator iter = m_dumpTrees.find(srcfile);
const auto iter = m_dumpTrees.find(srcfile);
if (iter != m_dumpTrees.end()) {
return iter->second;
} else {

15
src/V3Order.cpp
View File

@ -157,7 +157,7 @@ public:
V3List<OrderMoveVertex*>& readyVertices() { return m_readyVertices; }
static OrderMoveDomScope* findCreate(const AstSenTree* domainp, const AstScope* scopep) {
const DomScopeKey key = make_pair(domainp, scopep);
DomScopeMap::iterator iter = s_dsMap.find(key);
const auto iter = s_dsMap.find(key);
if (iter != s_dsMap.end()) {
return iter->second;
} else {
@ -1222,10 +1222,7 @@ public:
}
}
// Destruction
for (std::deque<OrderUser*>::iterator it = m_orderUserps.begin();
it != m_orderUserps.end(); ++it) {
delete *it;
}
for (OrderUser* ip : m_orderUserps) delete ip;
m_graph.debug(V3Error::debugDefault());
}
void main(AstNode* nodep) { iterate(nodep); }
@ -1573,9 +1570,7 @@ void OrderVisitor::processEdgeReport() {
*logp << "Signals and their clock domains:" << endl;
stable_sort(report.begin(), report.end());
for (std::deque<string>::iterator it = report.begin(); it != report.end(); ++it) {
*logp << (*it) << endl;
}
for (const string& i : report) *logp << i << endl;
}
void OrderVisitor::processMoveClear() {
@ -1888,9 +1883,7 @@ void OrderVisitor::processMTasks() {
const AstSenTree* last_domainp = nullptr;
AstCFunc* leafCFuncp = nullptr;
int leafStmts = 0;
for (MTaskState::Logics::iterator it = state.m_logics.begin(); it != state.m_logics.end();
++it) {
const OrderLogicVertex* logicp = *it;
for (const OrderLogicVertex* logicp : state.m_logics) {
if (logicp->domainp() != last_domainp) {
// Start a new leaf function.
leafCFuncp = nullptr;

24
src/V3Param.cpp
View File

@ -169,7 +169,7 @@ public:
AstConst* constp = VN_CAST(pinp->exprp(), Const);
UASSERT_OBJ(constp, pinp,
"parameter for a hierarchical block must have been constified");
ParamConstMap::const_iterator pIt = params.find(modvarp->name());
const auto pIt = vlstd::as_const(params).find(modvarp->name());
UINFO(5, "Comparing " << modvarp->name() << " " << constp << std::endl);
if (pIt == params.end() || paramIdx >= params.size()
|| !areSame(constp, pIt->second)) {
@ -190,7 +190,7 @@ public:
UASSERT_OBJ(modIt != m_hierBlockMod.end(), firstPinp,
hierIt->second->mangledName() << " is not found");
HierBlockModMap::const_iterator it = m_hierBlockMod.find(hierIt->second->mangledName());
const auto it = vlstd::as_const(m_hierBlockMod).find(hierIt->second->mangledName());
if (it == m_hierBlockMod.end()) return nullptr;
return it->second;
}
@ -309,7 +309,7 @@ private:
// Force hash collisions -- for testing only
if (VL_UNLIKELY(v3Global.opt.debugCollision())) hash = V3Hash();
int num;
ValueMap::iterator it = m_valueMap.find(hash);
const auto it = m_valueMap.find(hash);
if (it != m_valueMap.end() && it->second.second == key) {
num = it->second.first;
} else {
@ -355,12 +355,12 @@ private:
if (pinp->modVarp()) {
// Find it in the clone structure
// UINFO(8,"Clone find 0x"<<hex<<(uint32_t)pinp->modVarp()<<endl);
CloneMap::iterator cloneiter = clonemapp->find(pinp->modVarp());
const auto cloneiter = clonemapp->find(pinp->modVarp());
UASSERT_OBJ(cloneiter != clonemapp->end(), pinp,
"Couldn't find pin in clone list");
pinp->modVarp(VN_CAST(cloneiter->second, Var));
} else if (pinp->modPTypep()) {
CloneMap::iterator cloneiter = clonemapp->find(pinp->modPTypep());
const auto cloneiter = clonemapp->find(pinp->modPTypep());
UASSERT_OBJ(cloneiter != clonemapp->end(), pinp,
"Couldn't find pin in clone list");
pinp->modPTypep(VN_CAST(cloneiter->second, ParamTypeDType));
@ -380,7 +380,7 @@ private:
}
for (AstPin* pinp = startpinp; pinp; pinp = VN_CAST(pinp->nextp(), Pin)) {
if (AstVar* varp = pinp->modVarp()) {
std::map<string, AstVar*>::const_iterator varIt = nameToPin.find(varp->name());
const auto varIt = vlstd::as_const(nameToPin).find(varp->name());
UASSERT_OBJ(varIt != nameToPin.end(), varp,
"Not found in " << modp->prettyNameQ());
pinp->modVarp(varIt->second);
@ -444,7 +444,7 @@ private:
// Hitting a cell adds to the appropriate level of this level-sorted list,
// so since cells originally exist top->bottom we process in top->bottom order too.
while (!m_todoModps.empty()) {
LevelModMap::iterator itm = m_todoModps.begin();
const auto itm = m_todoModps.cbegin();
AstNodeModule* nodep = itm->second;
m_todoModps.erase(itm);
if (!nodep->user5SetOnce()) { // Process once; note clone() must clear so we do it
@ -457,8 +457,7 @@ private:
//
// Process interface cells, then non-interface which may ref an interface cell
for (int nonIf = 0; nonIf < 2; ++nonIf) {
for (CellList::iterator it = m_cellps.begin(); it != m_cellps.end(); ++it) {
AstCell* cellp = *it;
for (AstCell* cellp : m_cellps) {
if ((nonIf == 0 && VN_IS(cellp->modp(), Iface))
|| (nonIf == 1 && !VN_IS(cellp->modp(), Iface))) {
string fullName(m_modp->hierName());
@ -469,8 +468,7 @@ private:
}
}
}
for (CellList::iterator it = m_cellps.begin(); it != m_cellps.end(); ++it) {
AstCell* cellp = *it;
for (AstCell* cellp : m_cellps) {
if (string* genHierNamep = (string*)cellp->user5p()) {
cellp->user5p(nullptr);
VL_DO_DANGLING(delete genHierNamep, genHierNamep);
@ -964,7 +962,7 @@ void ParamVisitor::visitCell(AstCell* nodep, const string& hierName) {
// Shorter name is convenient for hierarchical block
string newname = longname;
if (longname.length() > 30 || srcModp->hierBlock()) {
LongMap::iterator iter = m_longMap.find(longname);
const auto iter = m_longMap.find(longname);
if (iter != m_longMap.end()) {
newname = iter->second;
} else {
@ -983,7 +981,7 @@ void ParamVisitor::visitCell(AstCell* nodep, const string& hierName) {
//
// Already made this flavor?
AstNodeModule* cellmodp = nullptr;
ModNameMap::iterator iter = m_modNameMap.find(newname);
auto iter = m_modNameMap.find(newname);
if (iter != m_modNameMap.end()) cellmodp = iter->second.m_modp;
if (!cellmodp) {
// Deep clone of new module

3
src/V3ParseSym.h
View File

@ -127,8 +127,7 @@ public:
}
void showUpward() {
UINFO(1, "ParseSym Stack:\n");
for (SymStack::reverse_iterator it = m_sympStack.rbegin(); it != m_sympStack.rend();
++it) {
for (auto it = m_sympStack.rbegin(); it != m_sympStack.rend(); ++it) {
VSymEnt* symp = *it;
UINFO(1, " " << symp->nodep() << endl);
}

17
src/V3Partition.cpp
View File

@ -244,7 +244,7 @@ public:
//
// This generalizes to multiple seed nodes also.
while (!m_pending.empty()) {
PropCpPendSet::reverse_iterator it = m_pending.rbegin();
const auto it = m_pending.rbegin();
V3GraphVertex* updateMep = (*it).key();
uint32_t cpGrowBy = (*it).value();
m_pending.erase(it);
@ -297,12 +297,12 @@ private:
// Confirm that we only set each node's CP once. That's an
// important property of PartPropagateCp which allows it to be far
// faster than a recursive algorithm on some graphs.
CpMap::iterator it = m_seen.find(vxp);
const auto it = m_seen.find(vxp);
UASSERT_OBJ(it == m_seen.end(), vxp, "Set CP on node twice");
m_seen[vxp] = cost;
}
uint32_t critPathCost(V3GraphVertex* vxp, GraphWay way) const {
CpMap::const_iterator it = m_cp.find(vxp);
const auto it = m_cp.find(vxp);
if (it != m_cp.end()) return it->second;
return 0;
}
@ -425,7 +425,7 @@ public:
LogicMTask* mtaskp = dynamic_cast<LogicMTask*>(vxp);
EdgeSet& edges = mtaskp->m_edges[way.invert()];
// This is mtaskp's relative with longest !wayward inclusive CP:
EdgeSet::reverse_iterator edgeIt = edges.rbegin();
const auto edgeIt = edges.rbegin();
uint32_t edgeCp = (*edgeIt).value();
UASSERT_OBJ(edgeCp == cp, vxp, "CP doesn't match longest wayward edge");
}
@ -686,8 +686,7 @@ public:
<< " (should match the computed critical path cost (CP) for the graph)\n";
// Dump
for (std::vector<const LogicMTask*>::iterator it = path.begin(); it != path.end(); ++it) {
const LogicMTask* mtaskp = *it;
for (const LogicMTask* mtaskp : path) {
*osp << "begin mtask with cost " << mtaskp->cost() << endl;
for (VxList::const_iterator lit = mtaskp->vertexListp()->begin();
lit != mtaskp->vertexListp()->end(); ++lit) {
@ -1523,7 +1522,7 @@ private:
// Don't make all NxN/2 possible pairs of prereqs, that's a lot
// to cart around. Just make a few pairs.
std::vector<LogicMTask*>::iterator it = shortestPrereqs.begin();
auto it = shortestPrereqs.cbegin();
for (unsigned i = 0; exhaustive || (i < 3); ++i) {
if (it == shortestPrereqs.end()) break;
LogicMTask* ap = *(it++);
@ -1834,7 +1833,7 @@ private:
rankIt->second.erase(mergedp);
while (!rankIt->second.empty()) {
LogicMTaskSet::iterator begin = rankIt->second.begin();
const auto begin = rankIt->second.cbegin();
LogicMTask* donorp = *begin;
UASSERT_OBJ(donorp != mergedp, donorp, "Donor can't be merged edge");
rankIt->second.erase(begin);
@ -2360,7 +2359,7 @@ void V3Partition::setupMTaskDeps(V3Graph* mtasksp, const Vx2MTaskMap* vx2mtaskp)
UASSERT(outp->weight() > 0, "Mtask not assigned weight");
const MTaskMoveVertex* top = dynamic_cast<MTaskMoveVertex*>(outp->top());
UASSERT(top, "MoveVertex not associated to mtask");
Vx2MTaskMap::const_iterator it = vx2mtaskp->find(top);
const auto it = vlstd::as_const(vx2mtaskp)->find(top);
UASSERT(it != vx2mtaskp->end(), "MTask map can't find id");
LogicMTask* otherMTaskp = it->second;
UASSERT(otherMTaskp, "nullptr other Mtask");

2
src/V3Partition.h
View File

@ -86,7 +86,7 @@ public:
PartPtrIdMap() {}
// METHODS
vluint64_t findId(const void* ptrp) const {
PtrMap::const_iterator it = m_id.find(ptrp);
const auto it = m_id.find(ptrp);
if (it != m_id.end()) return it->second;
m_id[ptrp] = m_nextId;
return m_nextId++;

14
src/V3PreProc.cpp
View File

@ -299,11 +299,11 @@ void V3PreProcImp::undefineall() {
}
}
bool V3PreProcImp::defExists(const string& name) {
DefinesMap::iterator iter = m_defines.find(name);
const auto iter = m_defines.find(name);
return (iter != m_defines.end());
}
string V3PreProcImp::defValue(const string& name) {
DefinesMap::iterator iter = m_defines.find(name);
const auto iter = m_defines.find(name);
if (iter == m_defines.end()) {
fileline()->v3error("Define or directive not defined: `" + name);
return "";
@ -311,7 +311,7 @@ string V3PreProcImp::defValue(const string& name) {
return iter->second.value();
}
string V3PreProcImp::defParams(const string& name) {
DefinesMap::iterator iter = m_defines.find(name);
const auto iter = m_defines.find(name);
if (iter == m_defines.end()) {
fileline()->v3error("Define or directive not defined: `" + name);
return "";
@ -319,7 +319,7 @@ string V3PreProcImp::defParams(const string& name) {
return iter->second.params();
}
FileLine* V3PreProcImp::defFileline(const string& name) {
DefinesMap::iterator iter = m_defines.find(name);
const auto iter = m_defines.find(name);
if (iter == m_defines.end()) return nullptr;
return iter->second.fileline();
}
@ -686,7 +686,7 @@ string V3PreProcImp::defineSubst(VDefineRef* refp) {
}
if (argName != "") {
// Found a possible variable substitution
std::map<string, string>::iterator iter = argValueByName.find(argName);
const auto iter = argValueByName.find(argName);
if (iter != argValueByName.end()) {
// Substitute
string subst = iter->second;
@ -795,9 +795,7 @@ void V3PreProcImp::openFile(FileLine* fl, VInFilter* filterp, const string& file
FileLine* flsp = new FileLine(filename);
flsp->lineno(1);
flsp->newContent();
for (StrList::iterator it = wholefile.begin(); it != wholefile.end(); ++it) {
flsp->contentp()->pushText(*it);
}
for (const string& i : wholefile) flsp->contentp()->pushText(i);
// Create new stream structure
m_lexp->scanNewFile(flsp);

3
src/V3Reloop.cpp
View File

@ -124,8 +124,7 @@ private:
if (debug() >= 9) whilep->dumpTree(cout, "-new: ");
// Remove remaining assigns
for (AssVec::iterator it = m_mgAssignps.begin(); it != m_mgAssignps.end(); ++it) {
AstNodeAssign* assp = *it;
for (AstNodeAssign* assp : m_mgAssignps) {
if (assp != bodyp) {
VL_DO_DANGLING(assp->unlinkFrBack()->deleteTree(), assp);
}

4
src/V3Scope.cpp
View File

@ -70,11 +70,11 @@ private:
AstVarRef* nodep = it->first;
AstScope* scopep = it->second;
if (nodep->packagep() && !nodep->varp()->isClassMember()) {
PackageScopeMap::iterator it2 = m_packageScopes.find(nodep->packagep());
const auto it2 = m_packageScopes.find(nodep->packagep());
UASSERT_OBJ(it2 != m_packageScopes.end(), nodep, "Can't locate package scope");
scopep = it2->second;
}
VarScopeMap::iterator it3 = m_varScopes.find(make_pair(nodep->varp(), scopep));
const auto it3 = m_varScopes.find(make_pair(nodep->varp(), scopep));
UASSERT_OBJ(it3 != m_varScopes.end(), nodep, "Can't locate varref scope");
AstVarScope* varscp = it3->second;
nodep->varScopep(varscp);

34
src/V3Scoreboard.h
View File

@ -247,16 +247,16 @@ private:
public:
iterator begin() {
typename Val2Keys::iterator valIt = m_vals.begin();
const auto valIt = m_vals.begin();
if (valIt == m_vals.end()) return end();
typename KeySet::const_iterator keyIt = valIt->second.begin();
const auto keyIt = valIt->second.begin();
return iterator(valIt, keyIt, this);
}
const_iterator begin() const {
SortByValueMap* mutp = const_cast<SortByValueMap*>(this);
typename Val2Keys::iterator valIt = mutp->m_vals.begin();
const auto valIt = mutp->m_vals.begin();
if (valIt == mutp->m_vals.end()) return end();
typename KeySet::const_iterator keyIt = valIt->second.begin();
const auto keyIt = valIt->second.begin();
return const_iterator(valIt, keyIt, mutp);
}
iterator end() { return iterator(this); }
@ -271,24 +271,24 @@ public:
const_reverse_iterator rend() const { return const_reverse_iterator(begin()); }
iterator find(const T_Key& k) {
typename Key2Val::iterator kvit = m_keys.find(k);
const auto kvit = m_keys.find(k);
if (kvit == m_keys.end()) return end();
typename Val2Keys::iterator valIt = m_vals.find(kvit->second);
typename KeySet::iterator keyIt = valIt->second.find(k);
const auto valIt = m_vals.find(kvit->second);
const auto keyIt = valIt->second.find(k);
return iterator(valIt, keyIt, this);
}
const_iterator find(const T_Key& k) const {
SortByValueMap* mutp = const_cast<SortByValueMap*>(this);
typename Key2Val::iterator kvit = mutp->m_keys.find(k);
const auto kvit = mutp->m_keys.find(k);
if (kvit == mutp->m_keys.end()) return end();
typename Val2Keys::iterator valIt = mutp->m_vals.find(kvit->second);
typename KeySet::iterator keyIt = valIt->second.find(k);
const auto valIt = mutp->m_vals.find(kvit->second);
const auto keyIt = valIt->second.find(k);
return const_iterator(valIt, keyIt, mutp);
}
void set(const T_Key& k, const T_Value& v) {
typename Key2Val::iterator kvit = m_keys.find(k);
const auto kvit = m_keys.find(k);
if (kvit != m_keys.end()) {
if (kvit->second == v) {
return; // LCOV_EXCL_LINE // Same value already present; stop.
@ -300,7 +300,7 @@ public:
m_vals[v].insert(k);
}
size_t erase(const T_Key& k) {
typename Key2Val::iterator kvit = m_keys.find(k);
const auto kvit = m_keys.find(k);
if (kvit == m_keys.end()) return 0;
removeKeyFromOldVal(k, kvit->second);
m_keys.erase(kvit);
@ -319,7 +319,7 @@ public:
// be a const reference, otherwise the client could corrupt the sorted
// order of m_byValue by reaching through and changing the value.
const T_Value& at(const T_Key& k) const {
typename Key2Val::const_iterator kvit = m_keys.find(k);
const auto kvit = m_keys.find(k);
UASSERT(kvit != m_keys.end(), "at() lookup key not found");
return kvit->second;
}
@ -415,7 +415,7 @@ public:
// reflected in the result of bestp(). Otherwise, bestp() only
// considers elements that aren't pending rescore.
const T_Elem* bestp() {
typename SortedMap::iterator result = m_sorted.begin();
const auto result = m_sorted.begin();
if (VL_UNLIKELY(result == m_sorted.end())) return nullptr;
return (*result).key();
}
@ -444,7 +444,7 @@ public:
bool needsRescore(const T_Elem* elp) { return (m_unknown.find(elp) != m_unknown.end()); }
// Retrieve the last known score for an element.
T_Score cachedScore(const T_Elem* elp) {
typename SortedMap::iterator result = m_sorted.find(elp);
const auto result = m_sorted.find(elp);
UASSERT(result != m_sorted.end(), "V3Scoreboard::cachedScore() failed to find element");
return (*result).value();
}
@ -452,9 +452,7 @@ public:
// call the client's scoring function to get a new score,
// and sort all elements by their current score.
void rescore() {
for (typename NeedRescoreSet::iterator it = m_unknown.begin(); it != m_unknown.end();
++it) {
const T_Elem* elp = *it;
for (const T_Elem* elp : m_unknown) {
T_Score sortScore = m_scoreFnp(elp);
m_sorted.set(elp, sortScore);
}

2
src/V3SenTree.h
View File

@ -60,7 +60,7 @@ public:
AstSenTree* find(AstSenTree* likep) {
AstSenTree* resultp = nullptr;
Set::iterator it = m_trees.find(likep);
const auto it = m_trees.find(likep);
if (it != m_trees.end()) resultp = *it;
return resultp;
}

13
src/V3Simulate.h
View File

@ -1009,7 +1009,7 @@ private:
string result;
string format = nodep->text();
string::const_iterator pos = format.begin();
auto pos = format.cbegin();
bool inPct = false;
for (; pos != format.end(); ++pos) {
if (!inPct && pos[0] == '%') {
@ -1132,15 +1132,10 @@ public:
mainGuts(nodep);
}
virtual ~SimulateVisitor() override {
for (ConstPile::iterator it = m_constAllps.begin(); it != m_constAllps.end(); ++it) {
for (ConstDeque::iterator it2 = it->second.begin(); it2 != it->second.end(); ++it2) {
delete (*it2);
}
}
for (std::deque<AstNode*>::iterator it = m_reclaimValuesp.begin();
it != m_reclaimValuesp.end(); ++it) {
delete (*it);
for (const auto& i : m_constAllps) {
for (AstConst* i2p : i.second) delete i2p;
}
for (AstNode* ip : m_reclaimValuesp) delete ip;
m_reclaimValuesp.clear();
m_constFreeps.clear();
m_constAllps.clear();

16
src/V3Split.cpp
View File

@ -394,18 +394,16 @@ protected:
SplitVarPostVertex* vpostp
= reinterpret_cast<SplitVarPostVertex*>(vscp->user2p());
// Add edges
for (VStack::iterator it = m_stmtStackps.begin(); it != m_stmtStackps.end();
++it) {
new SplitLVEdge(&m_graph, vpostp, *it);
for (SplitLogicVertex* vxp : m_stmtStackps) {
new SplitLVEdge(&m_graph, vpostp, vxp);
}
} else { // Nondelayed assignment
if (nodep->lvalue()) {
// Non-delay; need to maintain existing ordering
// with all consumers of the signal
UINFO(4, " VARREFLV: " << nodep << endl);
for (VStack::iterator it = m_stmtStackps.begin();
it != m_stmtStackps.end(); ++it) {
new SplitLVEdge(&m_graph, vstdp, *it);
for (SplitLogicVertex* ivxp : m_stmtStackps) {
new SplitLVEdge(&m_graph, vstdp, ivxp);
}
} else {
UINFO(4, " VARREF: " << nodep << endl);
@ -450,9 +448,7 @@ public:
// METHODS
protected:
virtual void makeRvalueEdges(SplitVarStdVertex* vstdp) override {
for (VStack::iterator it = m_stmtStackps.begin(); it != m_stmtStackps.end(); ++it) {
new SplitRVEdge(&m_graph, *it, vstdp);
}
for (SplitLogicVertex* vxp : m_stmtStackps) new SplitRVEdge(&m_graph, vxp, vstdp);
}
void cleanupBlockGraph(AstNode* nodep) {
@ -647,7 +643,7 @@ public:
// METHODS
const ColorSet& colors() const { return m_colors; }
const ColorSet& colors(AstNodeIf* nodep) const {
IfColorMap::const_iterator it = m_ifColors.find(nodep);
const auto it = m_ifColors.find(nodep);
UASSERT_OBJ(it != m_ifColors.end(), nodep, "Node missing from split color() map");
return it->second;
}

9
src/V3SplitVar.cpp
View File

@ -981,7 +981,7 @@ class SplitPackedVarVisitor : public AstNVisitor, public SplitVarImpl {
virtual void visit(AstVarRef* nodep) override {
AstVar* varp = nodep->varp();
visit(varp);
PackedVarRefMap::iterator refit = m_refs.find(varp);
const auto refit = m_refs.find(varp);
if (refit == m_refs.end()) return; // variable without split_var metacomment
UASSERT_OBJ(varp->attrSplitVar(), varp, "split_var attribute must be attached");
UASSERT_OBJ(!nodep->packagep(), nodep,
@ -1000,7 +1000,7 @@ class SplitPackedVarVisitor : public AstNVisitor, public SplitVarImpl {
}
AstVar* varp = vrefp->varp();
PackedVarRefMap::iterator refit = m_refs.find(varp);
const auto refit = m_refs.find(varp);
if (refit == m_refs.end()) {
iterateChildren(nodep);
return; // Variable without split_var metacomment
@ -1114,13 +1114,12 @@ class SplitPackedVarVisitor : public AstNVisitor, public SplitVarImpl {
}
static void updateReferences(AstVar* varp, PackedVarRef& ref,
const std::vector<SplitNewVar>& vars) {
typedef std::vector<SplitNewVar> NewVars; // Sorted by its lsb
for (int lvalue = 0; lvalue <= 1; ++lvalue) { // Refer the new split variables
std::vector<PackedVarRefEntry>& refs = lvalue ? ref.lhs() : ref.rhs();
for (PackedVarRef::iterator refit = refs.begin(), refitend = refs.end();
refit != refitend; ++refit) {
NewVars::const_iterator varit = std::upper_bound(
vars.begin(), vars.end(), refit->lsb(), SplitNewVar::Match());
auto varit = std::upper_bound(vars.begin(), vars.end(), refit->lsb(),
SplitNewVar::Match());
UASSERT_OBJ(varit != vars.end(), refit->nodep(), "Not found");
UASSERT(!(varit->msb() < refit->lsb() || refit->msb() < varit->lsb()),
"wrong search result");

4
src/V3String.cpp
View File

@ -74,13 +74,13 @@ string VString::dot(const string& a, const string& dot, const string& b) {
string VString::downcase(const string& str) {
string out = str;
for (string::iterator pos = out.begin(); pos != out.end(); ++pos) *pos = tolower(*pos);
for (auto& cr : out) cr = tolower(cr);
return out;
}
string VString::upcase(const string& str) {
string out = str;
for (string::iterator pos = out.begin(); pos != out.end(); ++pos) *pos = toupper(*pos);
for (auto& cr : out) cr = toupper(cr);
return out;
}

7
src/V3Subst.cpp
View File

@ -372,10 +372,9 @@ public:
}
virtual ~SubstVisitor() override {
V3Stats::addStat("Optimizations, Substituted temps", m_statSubsts);
for (std::vector<SubstVarEntry*>::iterator it = m_entryps.begin(); it != m_entryps.end();
++it) {
(*it)->deleteUnusedAssign();
delete (*it);
for (SubstVarEntry* ip : m_entryps) {
ip->deleteUnusedAssign();
delete ip;
}
}
};

10
src/V3SymTable.h
View File

@ -133,7 +133,7 @@ public:
}
}
void reinsert(const string& name, VSymEnt* entp) {
IdNameMap::iterator it = m_idNameMap.find(name);
const auto it = m_idNameMap.find(name);
if (name != "" && it != m_idNameMap.end()) {
UINFO(9, " SymReinsert se" << cvtToHex(this) << " '" << name << "' se"
<< cvtToHex(entp) << " " << entp->nodep() << endl);
@ -145,7 +145,7 @@ public:
VSymEnt* findIdFlat(const string& name) const {
// Find identifier without looking upward through symbol hierarchy
// First, scan this begin/end block or module for the name
IdNameMap::const_iterator it = m_idNameMap.find(name);
const auto it = m_idNameMap.find(name);
UINFO(9, " SymFind se"
<< cvtToHex(this) << " '" << name << "' -> "
<< (it == m_idNameMap.end()
@ -211,7 +211,7 @@ public:
void importFromPackage(VSymGraph* graphp, const VSymEnt* srcp, const string& id_or_star) {
// Import tokens from source symbol table into this symbol table
if (id_or_star != "*") {
IdNameMap::const_iterator it = srcp->m_idNameMap.find(id_or_star);
const auto it = srcp->m_idNameMap.find(id_or_star);
if (it != srcp->m_idNameMap.end()) {
importOneSymbol(graphp, it->first, it->second, true);
}
@ -225,7 +225,7 @@ public:
void exportFromPackage(VSymGraph* graphp, const VSymEnt* srcp, const string& id_or_star) {
// Export tokens from source symbol table into this symbol table
if (id_or_star != "*") {
IdNameMap::const_iterator it = srcp->m_idNameMap.find(id_or_star);
const auto it = vlstd::as_const(srcp->m_idNameMap).find(id_or_star);
if (it != srcp->m_idNameMap.end()) exportOneSymbol(graphp, it->first, it->second);
} else {
for (IdNameMap::const_iterator it = srcp->m_idNameMap.begin();
@ -292,7 +292,7 @@ class VSymGraph {
public:
explicit VSymGraph(AstNetlist* nodep) { m_symRootp = new VSymEnt(this, nodep); }
~VSymGraph() {
for (SymStack::iterator it = m_symsp.begin(); it != m_symsp.end(); ++it) delete (*it);
for (const VSymEnt* entp : m_symsp) delete entp;
}
// METHODS

14
src/V3TSP.cpp
View File

@ -84,7 +84,7 @@ public:
// METHODS
void addVertex(const T_Key& key) {
typename VMap::iterator itr = m_vertices.find(key);
const auto itr = m_vertices.find(key);
UASSERT(itr == m_vertices.end(), "Vertex already exists with same key");
Vertex* v = new Vertex(this, key);
m_vertices[key] = v;
@ -177,7 +177,7 @@ public:
// discard it and repeat again.
unsigned edges_made = 0;
while (!pendingEdges.empty()) {
typename PendingEdgeSet::iterator firstIt = pendingEdges.begin();
const auto firstIt = pendingEdges.cbegin();
V3GraphEdge* bestEdgep = *firstIt;
pendingEdges.erase(firstIt);
@ -317,8 +317,7 @@ public:
// Look for nodes on the tour that still have
// un-marked edges. If we find one, recurse.
for (typename std::vector<Vertex*>::iterator it = tour.begin(); it != tour.end(); ++it) {
Vertex* vxp = *it;
for (Vertex* vxp : tour) {
bool recursed;
do {
recursed = false;
@ -338,10 +337,7 @@ public:
}
UINFO(6, "Tour was: ");
for (typename std::vector<Vertex*>::iterator it = tour.begin(); it != tour.end(); ++it) {
Vertex* vxp = *it;
UINFONL(6, " " << vxp->key());
}
for (const Vertex* vxp : tour) UINFONL(6, " " << vxp->key());
UINFONL(6, "\n");
}
@ -390,7 +386,7 @@ public:
private:
Vertex* findVertex(const T_Key& key) const {
typename VMap::const_iterator it = m_vertices.find(key);
const auto it = m_vertices.find(key);
UASSERT(it != m_vertices.end(), "Vertex not found");
return it->second;
}

26
src/V3Table.cpp
View File

@ -224,16 +224,14 @@ private:
// Create table for each output
typedef std::map<string, int> NameCounts;
NameCounts namecounts;
for (std::deque<AstVarScope*>::iterator it = m_outVarps.begin(); it != m_outVarps.end();
++it) {
AstVarScope* outvscp = *it;
for (const AstVarScope* outvscp : m_outVarps) {
AstVar* outvarp = outvscp->varp();
FileLine* fl = nodep->fileline();
AstNodeArrayDType* dtypep = new AstUnpackArrayDType(
fl, outvarp->dtypep(), new AstRange(fl, VL_MASK_I(m_inWidth), 0));
v3Global.rootp()->typeTablep()->addTypesp(dtypep);
string name = "__Vtable" + cvtToStr(m_modTables) + "_" + outvarp->name();
NameCounts::iterator nit = namecounts.find(name);
const auto nit = namecounts.find(name);
if (nit != namecounts.end()) {
// Multiple scopes can have same var name. We could append the
// scope name but that is very long, so just deduplicate.
@ -256,9 +254,7 @@ private:
// Concat inputs into a single temp variable (inside always)
// First var in inVars becomes the LSB of the concat
AstNode* concatp = nullptr;
for (std::deque<AstVarScope*>::iterator it = m_inVarps.begin(); it != m_inVarps.end();
++it) {
AstVarScope* invscp = *it;
for (AstVarScope* invscp : m_inVarps) {
AstVarRef* refp = new AstVarRef(nodep->fileline(), invscp, false);
if (concatp) {
concatp = new AstConcat(nodep->fileline(), refp, concatp);
@ -293,9 +289,7 @@ private:
// Set all inputs to the constant
uint32_t shift = 0;
for (std::deque<AstVarScope*>::iterator it = m_inVarps.begin(); it != m_inVarps.end();
++it) {
AstVarScope* invscp = *it;
for (AstVarScope* invscp : m_inVarps) {
// LSB is first variable, so extract it that way
AstConst cnst(invscp->fileline(), AstConst::WidthedValue(), invscp->width(),
VL_MASK_I(invscp->width()) & (inValue >> shift));
@ -316,9 +310,7 @@ private:
// If a output changed, add it to table
int outnum = 0;
V3Number outputChgMask(nodep, m_outVarps.size(), 0);
for (std::deque<AstVarScope*>::iterator it = m_outVarps.begin();
it != m_outVarps.end(); ++it) {
AstVarScope* outvscp = *it;
for (AstVarScope* outvscp : m_outVarps) {
V3Number* outnump = simvis.fetchOutNumberNull(outvscp);
AstNode* setp;
if (!outnump) {
@ -353,9 +345,7 @@ private:
// See if another table we've created is identical, if so use it for both.
// (A more 'modern' way would be to instead use V3Hashed::findDuplicate)
AstVar* var1p = vsc1p->varp();
for (std::deque<AstVarScope*>::iterator it = m_modTableVscs.begin();
it != m_modTableVscs.end(); ++it) {
AstVarScope* vsc2p = *it;
for (AstVarScope* vsc2p : m_modTableVscs) {
AstVar* var2p = vsc2p->varp();
if (var1p->width() == var2p->width()
&& (var1p->dtypep()->arrayUnpackedElements()
@ -381,9 +371,7 @@ private:
// elimination will remove it for us.
// Set each output from array ref into our table
int outnum = 0;
for (std::deque<AstVarScope*>::iterator it = m_outVarps.begin(); it != m_outVarps.end();
++it) {
AstVarScope* outvscp = *it;
for (AstVarScope* outvscp : m_outVarps) {
AstNode* alhsp = new AstVarRef(nodep->fileline(), outvscp, true);
AstNode* arhsp = new AstArraySel(
nodep->fileline(), new AstVarRef(nodep->fileline(), m_tableVarps[outnum], false),

9
src/V3Task.cpp
View File

@ -121,7 +121,7 @@ public:
return scopep;
}
AstVarScope* findVarScope(AstScope* scopep, AstVar* nodep) {
VarToScopeMap::iterator iter = m_varToScopeMap.find(make_pair(scopep, nodep));
const auto iter = m_varToScopeMap.find(make_pair(scopep, nodep));
UASSERT_OBJ(iter != m_varToScopeMap.end(), nodep, "No scope for var");
return iter->second;
}
@ -233,8 +233,7 @@ private:
iterateChildren(nodep);
}
UASSERT_OBJ(m_ctorp, nodep, "class constructor missing"); // LinkDot always makes it
for (Initials::iterator it = m_initialps.begin(); it != m_initialps.end(); ++it) {
AstInitial* initialp = *it;
for (AstInitial* initialp : m_initialps) {
if (AstNode* newp = initialp->bodysp()) {
newp->unlinkFrBackWithNext();
if (!m_ctorp->stmtsp()) {
@ -812,7 +811,7 @@ private:
bool duplicatedDpiProto(AstNodeFTask* nodep, const string& dpiproto) {
// Only create one DPI extern prototype for each specified cname
// as it's legal for the user to attach multiple tasks to one dpi cname
DpiNames::iterator iter = m_dpiNames.find(nodep->cname());
const auto iter = m_dpiNames.find(nodep->cname());
if (iter == m_dpiNames.end()) {
m_dpiNames.insert(make_pair(nodep->cname(), make_pair(nodep, dpiproto)));
return false;
@ -1401,7 +1400,7 @@ V3TaskConnects V3Task::taskConnects(AstNodeFTaskRef* nodep, AstNode* taskStmtsp)
UASSERT_OBJ(argp, pinp, "Non-arg under ftask reference");
if (argp->name() != "") {
// By name
NameToIndex::iterator it = nameToIndex.find(argp->name());
const auto it = nameToIndex.find(argp->name());
if (it == nameToIndex.end()) {
pinp->v3error("No such argument " << argp->prettyNameQ() << " in function call to "
<< nodep->taskp()->prettyTypeName());

15
src/V3Trace.cpp
View File

@ -220,7 +220,7 @@ private:
if (TraceTraceVertex* const vvertexp = dynamic_cast<TraceTraceVertex*>(itp)) {
AstTraceDecl* const nodep = vvertexp->nodep();
if (nodep->valuep() && !vvertexp->duplicatep()) {
V3Hashed::iterator dupit = hashed.findDuplicate(nodep->valuep());
const auto dupit = hashed.findDuplicate(nodep->valuep());
if (dupit != hashed.end()) {
const AstTraceDecl* const dupDeclp
= VN_CAST_CONST(hashed.iteratorNodep(dupit)->backp(), TraceDecl);
@ -381,10 +381,10 @@ private:
// For each activity set with only a small number of signals, make those
// signals always traced, as it's cheaper to check a few value changes
// than to test a lot of activity flags
TraceVec::iterator it = traces.begin();
const TraceVec::iterator end = traces.end();
auto it = traces.begin();
const auto end = traces.end();
while (it != end) {
TraceVec::iterator head = it;
auto head = it;
// Approximate the complexity of the value change check
uint32_t complexity = 0;
const ActCodeSet& actSet = it->first;
@ -533,8 +533,8 @@ private:
int topFuncNum = 0;
int subFuncNum = 0;
TraceVec::const_iterator it = traces.begin();
while (it != traces.end()) {
auto it = traces.cbegin();
while (it != traces.cend()) {
AstCFunc* topFuncp = nullptr;
AstCFunc* subFuncp = nullptr;
int subStmts = 0;
@ -637,8 +637,7 @@ private:
if (always) {
condp = new AstConst(flp, 1); // Always true, will be folded later
} else {
for (ActCodeSet::iterator it = actSet.begin(); it != actSet.end(); ++it) {
const uint32_t actCode = *it;
for (const uint32_t actCode : actSet) {
AstNode* const selp = selectActivity(flp, actCode, false);
condp = condp ? new AstOr(flp, condp, selp) : selp;
}

4
src/V3Tristate.cpp
View File

@ -421,7 +421,7 @@ class TristateVisitor : public TristateBaseVisitor {
void mapInsertLhsVarRef(AstVarRef* nodep) {
AstVar* key = nodep->varp();
VarMap::iterator it = m_lhsmap.find(key);
const auto it = m_lhsmap.find(key);
UINFO(9, " mapInsertLhsVarRef " << nodep << endl);
if (it == m_lhsmap.end()) { // Not found
RefVec* refsp = new RefVec();
@ -482,7 +482,7 @@ class TristateVisitor : public TristateBaseVisitor {
for (TristateGraph::VarVec::iterator ii = vars.begin(); ii != vars.end(); ++ii) {
AstVar* varp = (*ii);
if (m_tgraph.isTristate(varp)) {
VarMap::iterator it = m_lhsmap.find(varp);
const auto it = m_lhsmap.find(varp);
if (it == m_lhsmap.end()) {
// set output enable to always be off on this assign
// statement so that this var is floating

10
src/V3Undriven.cpp
View File

@ -441,15 +441,9 @@ public:
// CONSTRUCTORS
explicit UndrivenVisitor(AstNetlist* nodep) { iterate(nodep); }
virtual ~UndrivenVisitor() override {
for (std::vector<UndrivenVarEntry*>::iterator it = m_entryps[1].begin();
it != m_entryps[1].end(); ++it) {
(*it)->reportViolations();
}
for (UndrivenVarEntry* ip : m_entryps[1]) ip->reportViolations();
for (int usr = 1; usr < 3; ++usr) {
for (std::vector<UndrivenVarEntry*>::iterator it = m_entryps[usr].begin();
it != m_entryps[usr].end(); ++it) {
delete (*it);
}
for (UndrivenVarEntry* ip : m_entryps[usr]) delete ip;
}
}
};

10
src/V3Width.cpp
View File

@ -2876,7 +2876,7 @@ private:
AstNode* newp = nullptr;
for (AstMemberDType* memp = vdtypep->membersp(); memp;
memp = VN_CAST(memp->nextp(), MemberDType)) {
PatMap::iterator it = patmap.find(memp);
const auto it = patmap.find(memp);
AstPatMember* newpatp = nullptr;
AstPatMember* patp = nullptr;
if (it == patmap.end()) {
@ -2923,7 +2923,7 @@ private:
for (int ent = range.hi(); ent >= range.lo(); --ent) {
AstPatMember* newpatp = nullptr;
AstPatMember* patp = nullptr;
PatVecMap::iterator it = patmap.find(ent);
const auto it = patmap.find(ent);
if (it == patmap.end()) {
if (defaultp) {
newpatp = defaultp->cloneTree(false);
@ -2978,7 +2978,7 @@ private:
for (int ent = range.hi(); ent >= range.lo(); --ent) {
AstPatMember* newpatp = nullptr;
AstPatMember* patp = nullptr;
PatVecMap::iterator it = patmap.find(ent);
const auto it = patmap.find(ent);
if (it == patmap.end()) {
if (defaultp) {
newpatp = defaultp->cloneTree(false);
@ -5158,7 +5158,7 @@ private:
}
AstVar* dimensionVarp(AstNodeDType* nodep, AstAttrType attrType, uint32_t msbdim) {
// Return a variable table which has specified dimension properties for this variable
TableMap::iterator pos = m_tableMap.find(make_pair(nodep, attrType));
const auto pos = m_tableMap.find(make_pair(nodep, attrType));
if (pos != m_tableMap.end()) return pos->second;
AstNodeArrayDType* vardtypep
= new AstUnpackArrayDType(nodep->fileline(), nodep->findSigned32DType(),
@ -5185,7 +5185,7 @@ private:
}
AstVar* enumVarp(AstEnumDType* nodep, AstAttrType attrType, uint32_t msbdim) {
// Return a variable table which has specified dimension properties for this variable
TableMap::iterator pos = m_tableMap.find(make_pair(nodep, attrType));
const auto pos = m_tableMap.find(make_pair(nodep, attrType));
if (pos != m_tableMap.end()) return pos->second;
UINFO(9, "Construct Venumtab attr=" << attrType.ascii() << " max=" << msbdim << " for "
<< nodep << endl);

10
src/VlcMain.cpp
View File

@ -154,10 +154,7 @@ int main(int argc, char** argv, char** /*env*/) {
{
const VlStringSet& readFiles = top.opt.readFiles();
for (VlStringSet::const_iterator it = readFiles.begin(); it != readFiles.end(); ++it) {
string filename = *it;
top.readCoverage(filename);
}
for (const auto& filename : readFiles) top.readCoverage(filename);
}
if (debug() >= 9) {
@ -179,10 +176,7 @@ int main(int argc, char** argv, char** /*env*/) {
V3Error::abortIfWarnings();
if (top.opt.unlink()) {
const VlStringSet& readFiles = top.opt.readFiles();
for (VlStringSet::const_iterator it = readFiles.begin(); it != readFiles.end(); ++it) {
string filename = *it;
unlink(filename.c_str());
}
for (const auto& filename : readFiles) { unlink(filename.c_str()); }
}
}

6
src/VlcPoint.h
View File

@ -113,15 +113,15 @@ public:
void dump() {
UINFO(2, "dumpPoints...\n");
VlcPoint::dumpHeader();
for (VlcPoints::ByName::const_iterator it = begin(); it != end(); ++it) {
const VlcPoint& point = pointNumber(it->second);
for (const auto& i : *this) {
const VlcPoint& point = pointNumber(i.second);
point.dump();
}
}
VlcPoint& pointNumber(vluint64_t num) { return m_points[num]; }
vluint64_t findAddPoint(const string& name, vluint64_t count) {
vluint64_t pointnum;
NameMap::const_iterator iter = m_nameMap.find(name);
const auto iter = m_nameMap.find(name);
if (iter != m_nameMap.end()) {
pointnum = iter->second;
m_points[pointnum].countInc(count);

10
src/VlcTest.h
View File

@ -102,18 +102,14 @@ public:
// CONSTRUCTORS
VlcTests() {}
~VlcTests() {
for (VlcTests::ByName::iterator it = begin(); it != end(); ++it) {
VL_DO_CLEAR(delete *it, *it = nullptr);
}
for (auto it = begin(); it != end(); ++it) { VL_DO_CLEAR(delete *it, *it = nullptr); }
}
// METHODS
void dump(bool bucketsToo) {
UINFO(2, "dumpTests...\n");
VlcTest::dumpHeader();
for (VlcTests::ByName::const_iterator it = begin(); it != end(); ++it) {
(*it)->dump(bucketsToo);
}
for (const auto& testp : m_tests) testp->dump(bucketsToo);
}
VlcTest* newTest(const string& name, vluint64_t testrun, double comp) {
VlcTest* testp = new VlcTest(name, testrun, comp);
@ -121,7 +117,7 @@ public:
return testp;
}
void clearUser() {
for (ByName::iterator it = m_tests.begin(); it != m_tests.end(); ++it) (*it)->user(0);
for (const auto& testp : m_tests) testp->user(0);
}
};

56
src/VlcTop.cpp
View File

@ -70,8 +70,8 @@ void VlcTop::writeCoverage(const string& filename) {
}
os << "# SystemC::Coverage-3" << endl;
for (VlcPoints::ByName::const_iterator it = m_points.begin(); it != m_points.end(); ++it) {
const VlcPoint& point = m_points.pointNumber(it->second);
for (const auto& i : m_points) {
const VlcPoint& point = m_points.pointNumber(i.second);
os << "C '" << point.name() << "' " << point.count() << endl;
}
}
@ -107,17 +107,17 @@ void VlcTop::writeInfo(const string& filename) {
// end_of_record
os << "TN:verilator_coverage\n";
for (VlcSources::NameMap::iterator sit = m_sources.begin(); sit != m_sources.end(); ++sit) {
VlcSource& source = sit->second;
for (auto& si : m_sources) {
VlcSource& source = si.second;
os << "SF:" << source.name() << endl;
VlcSource::LinenoMap& lines = source.lines();
for (VlcSource::LinenoMap::iterator lit = lines.begin(); lit != lines.end(); ++lit) {
int lineno = lit->first;
VlcSource::ColumnMap& cmap = lit->second;
for (auto& li : lines) {
int lineno = li.first;
VlcSource::ColumnMap& cmap = li.second;
bool first = true;
vluint64_t min_count = 0; // Minimum across all columns on line
for (VlcSource::ColumnMap::iterator cit = cmap.begin(); cit != cmap.end(); ++cit) {
VlcSourceCount& col = cit->second;
for (auto& ci : cmap) {
VlcSourceCount& col = ci.second;
if (first) {
min_count = col.count();
first = false;
@ -148,17 +148,16 @@ void VlcTop::rank() {
// Sort by computrons, so fast tests get selected first
std::vector<VlcTest*> bytime;
for (VlcTests::ByName::const_iterator it = m_tests.begin(); it != m_tests.end(); ++it) {
VlcTest* testp = *it;
for (const auto& testp : m_tests) {
if (testp->bucketsCovered()) { // else no points, so can't help us
bytime.push_back(*it);
bytime.push_back(testp);
}
}
sort(bytime.begin(), bytime.end(), CmpComputrons()); // Sort the vector
VlcBuckets remaining;
for (VlcPoints::ByName::const_iterator it = m_points.begin(); it != m_points.end(); ++it) {
VlcPoint* pointp = &points().pointNumber(it->second);
for (const auto& i : m_points) {
VlcPoint* pointp = &points().pointNumber(i.second);
// If any tests hit this point, then we'll need to cover it.
if (pointp->testsCovering()) remaining.addData(pointp->pointNum(), 1);
}
@ -174,8 +173,7 @@ void VlcTop::rank() {
}
VlcTest* bestTestp = nullptr;
vluint64_t bestRemain = 0;
for (std::vector<VlcTest*>::iterator it = bytime.begin(); it != bytime.end(); ++it) {
VlcTest* testp = *it;
for (const auto& testp : bytime) {
if (!testp->rank()) {
vluint64_t remain = testp->buckets().dataPopCount(remaining);
if (remain > bestRemain) {
@ -198,8 +196,8 @@ void VlcTop::rank() {
void VlcTop::annotateCalc() {
// Calculate per-line information into filedata structure
for (VlcPoints::ByName::const_iterator it = m_points.begin(); it != m_points.end(); ++it) {
const VlcPoint& point = m_points.pointNumber(it->second);
for (const auto& i : m_points) {
const VlcPoint& point = m_points.pointNumber(i.second);
string filename = point.filename();
int lineno = point.lineno();
if (!filename.empty() && lineno != 0) {
@ -244,15 +242,15 @@ void VlcTop::annotateCalcNeeded() {
// coverage in all categories
int totCases = 0;
int totOk = 0;
for (VlcSources::NameMap::iterator sit = m_sources.begin(); sit != m_sources.end(); ++sit) {
VlcSource& source = sit->second;
for (auto& si : m_sources) {
VlcSource& source = si.second;
// UINFO(1,"Source "<<source.name()<<endl);
if (opt.annotateAll()) source.needed(true);
VlcSource::LinenoMap& lines = source.lines();
for (VlcSource::LinenoMap::iterator lit = lines.begin(); lit != lines.end(); ++lit) {
VlcSource::ColumnMap& cmap = lit->second;
for (VlcSource::ColumnMap::iterator cit = cmap.begin(); cit != cmap.end(); ++cit) {
VlcSourceCount& col = cit->second;
for (auto& li : lines) {
VlcSource::ColumnMap& cmap = li.second;
for (auto& ci : cmap) {
VlcSourceCount& col = ci.second;
// UINFO(0,"Source "<<source.name()<<":"<<col.lineno()<<":"<<col.column()<<endl);
++totCases;
if (col.ok()) {
@ -272,8 +270,8 @@ void VlcTop::annotateCalcNeeded() {
void VlcTop::annotateOutputFiles(const string& dirname) {
// Create if uncreated, ignore errors
V3Os::createDir(dirname);
for (VlcSources::NameMap::iterator sit = m_sources.begin(); sit != m_sources.end(); ++sit) {
VlcSource& source = sit->second;
for (auto& si : m_sources) {
VlcSource& source = si.second;
if (!source.needed()) continue;
string filename = source.name();
string outfilename = dirname + "/" + V3Os::filenameNonDir(filename);
@ -302,11 +300,11 @@ void VlcTop::annotateOutputFiles(const string& dirname) {
bool first = true;
VlcSource::LinenoMap& lines = source.lines();
VlcSource::LinenoMap::iterator lit = lines.find(lineno);
const auto lit = lines.find(lineno);
if (lit != lines.end()) {
VlcSource::ColumnMap& cmap = lit->second;
for (VlcSource::ColumnMap::iterator cit = cmap.begin(); cit != cmap.end(); ++cit) {
VlcSourceCount& col = cit->second;
for (auto& ci : cmap) {
VlcSourceCount& col = ci.second;
// UINFO(0,"Source
// "<<source.name()<<":"<<col.lineno()<<":"<<col.column()<<endl);
os << (col.ok() ? " " : "%") << std::setfill('0') << std::setw(6)

34
test_regress/t/t_scope_map.cpp
View File

@ -48,19 +48,18 @@ int main(int argc, char** argv, char** env) {
return -1;
}
for (VerilatedVarNameMap::iterator varIt = varNameMap->begin(); varIt != varNameMap->end();
++varIt) {
VerilatedVar* var = &varIt->second;
int varLeft = var->packed().left();
int varRight = var->packed().right();
for (const auto& varname : *varNameMap) {
const VerilatedVar* varp = &(varname.second);
int varLeft = varp->packed().left();
int varRight = varp->packed().right();
#ifdef TEST_VERBOSE
VL_PRINTF("\tVar = %s\n", varIt->first);
VL_PRINTF("\t Type = %d\n", var->vltype());
VL_PRINTF("\t EntSize = %d\n", var->entSize());
VL_PRINTF("\t Dims = %d\n", var->dims());
VL_PRINTF("\tVar = %s\n", varname.first);
VL_PRINTF("\t Type = %d\n", varp->vltype());
VL_PRINTF("\t EntSize = %d\n", varp->entSize());
VL_PRINTF("\t Dims = %d\n", varp->dims());
VL_PRINTF("\t Range = %d:%d\n", varLeft, varRight);
VL_PRINTF("\t Is RW = %d\n", var->isPublicRW());
VL_PRINTF("\t Is RW = %d\n", varp->isPublicRW());
#endif
if (varRight != 0) {
@ -71,7 +70,7 @@ int main(int argc, char** argv, char** env) {
int varBits = varLeft + 1;
// First expect an incrementing byte pattern
vluint8_t* varData = reinterpret_cast<vluint8_t*>(var->datap());
vluint8_t* varData = reinterpret_cast<vluint8_t*>(varp->datap());
for (int i = 0; i < varBits / 8; i++) {
#ifdef TEST_VERBOSE
VL_PRINTF("%02x ", varData[i]);
@ -124,19 +123,18 @@ int main(int argc, char** argv, char** env) {
return -1;
}
for (VerilatedVarNameMap::iterator varIt = varNameMap->begin(); varIt != varNameMap->end();
++varIt) {
VerilatedVar* var = &varIt->second;
int varLeft = var->packed().left();
for (const auto& varname : *varNameMap) {
const VerilatedVar* varp = &(varname.second);
int varLeft = varp->packed().left();
int varBits = varLeft + 1;
vluint8_t* varData = reinterpret_cast<vluint8_t*>(var->datap());
vluint8_t* varData = reinterpret_cast<vluint8_t*>(varp->datap());
// Check that all bits are high now
for (int i = 0; i < varBits / 8; i++) {
vluint8_t expected = 0xff;
if (varData[i] != expected) {
VL_PRINTF("%%Error: Data mismatch (%s), got 0x%02x, expected 0x%02x\n",
varIt->first, varData[i], expected);
varname.first, varData[i], expected);
return -1;
}
}
@ -146,7 +144,7 @@ int main(int argc, char** argv, char** env) {
vluint8_t expected = ~(0xff << (varBits % 8));
if (got != expected) {
VL_PRINTF("%%Error: Data mismatch (%s), got 0x%02x, expected 0x%02x\n",
varIt->first, got, expected);
varname.first, got, expected);
return -1;
}
}