From fa904f386c2b5fd02c97aa86b82816c421cf7037 Mon Sep 17 00:00:00 2001 From: Wilson Snyder Date: Mon, 9 Sep 2019 07:50:21 -0400 Subject: [PATCH] Commentary - Spelling fixes --- src/V3Active.cpp | 4 ++-- src/V3AssertPre.cpp | 2 +- src/V3Ast.cpp | 4 ++-- src/V3Ast.h | 10 +++++----- src/V3AstNodes.h | 4 ++-- src/V3Case.cpp | 4 ++-- src/V3Cast.cpp | 4 ++-- src/V3Cdc.cpp | 2 +- src/V3Clean.cpp | 2 +- src/V3Clock.cpp | 2 +- src/V3Combine.cpp | 2 +- src/V3Config.cpp | 2 +- src/V3Const.cpp | 16 ++++++++-------- src/V3Coverage.cpp | 2 +- src/V3Dead.cpp | 2 +- src/V3Delayed.cpp | 2 +- src/V3Depth.cpp | 2 +- src/V3Descope.cpp | 2 +- src/V3EmitC.cpp | 6 +++--- src/V3EmitCSyms.cpp | 2 +- src/V3Error.h | 2 +- src/V3Expand.cpp | 2 +- src/V3File.cpp | 2 +- src/V3Gate.cpp | 2 +- src/V3GraphAcyc.cpp | 4 ++-- src/V3GraphDfa.cpp | 2 +- src/V3GraphStream.h | 4 ++-- src/V3Inst.cpp | 2 +- src/V3LinkDot.cpp | 4 ++-- src/V3LinkJump.cpp | 2 +- src/V3LinkLevel.cpp | 4 ++-- src/V3Number.cpp | 2 +- src/V3Options.cpp | 2 +- src/V3Order.cpp | 4 ++-- src/V3Param.cpp | 2 +- src/V3Partition.cpp | 4 ++-- src/V3PreProc.cpp | 12 ++++++------ src/V3PreShell.cpp | 2 +- src/V3Premit.cpp | 2 +- src/V3Scope.cpp | 2 +- src/V3Simulate.h | 2 +- src/V3String.cpp | 2 +- src/V3String.h | 2 +- src/V3TSP.cpp | 2 +- src/V3Table.cpp | 4 ++-- src/V3TraceDecl.cpp | 2 +- src/V3Tristate.cpp | 6 +++--- src/V3Undriven.cpp | 2 +- src/V3Width.cpp | 2 +- src/V3WidthSel.cpp | 4 ++-- 50 files changed, 83 insertions(+), 83 deletions(-) diff --git a/src/V3Active.cpp b/src/V3Active.cpp index 99fcc3a5c..70226b0d5 100644 --- a/src/V3Active.cpp +++ b/src/V3Active.cpp @@ -196,7 +196,7 @@ private: AstVar* varp = nodep->varp(); if (m_check == CT_SEQ && m_assignp - && !varp->isUsedLoopIdx() // Ignore loop indicies + && !varp->isUsedLoopIdx() // Ignore loop indices && !varp->isTemp()) { // Allow turning off warnings on the always, or the variable also if (!m_alwaysp->fileline()->warnIsOff(V3ErrorCode::BLKSEQ) @@ -320,7 +320,7 @@ private: return; } - // Read sensitivitues + // Read sensitivities m_itemCombo = false; m_itemSequent = false; iterateAndNextNull(oldsensesp); diff --git a/src/V3AssertPre.cpp b/src/V3AssertPre.cpp index 22bf7a3b0..72fe8f13b 100644 --- a/src/V3AssertPre.cpp +++ b/src/V3AssertPre.cpp @@ -95,7 +95,7 @@ private: virtual void visit(AstNodePslCoverOrAssert* nodep) { if (nodep->sentreep()) return; // Already processed clearAssertInfo(); - // Find PslClocking's burried under nodep->exprsp + // Find PslClocking's buried under nodep->exprsp iterateChildren(nodep); nodep->sentreep(newSenTree(nodep)); clearAssertInfo(); diff --git a/src/V3Ast.cpp b/src/V3Ast.cpp index d9fd182de..bf9fd40ac 100644 --- a/src/V3Ast.cpp +++ b/src/V3Ast.cpp @@ -262,7 +262,7 @@ AstNode* AstNode::addNext(AstNode* nodep, AstNode* newp) { UDEBUGONLY(UASSERT_OBJ(!oldtailp->m_nextp, nodep, "Node had next, but headtail says it shouldn't");); } else { - // Though inefficent, we are occasionally passed a addNext in the middle of a list. + // Though inefficient, we are occasionally passed a addNext in the middle of a list. while (oldtailp->m_nextp != NULL) oldtailp = oldtailp->m_nextp; } } @@ -1090,7 +1090,7 @@ string AstNode::locationStr() const { const AstScope* scopep; if ((scopep = VN_CAST_CONST(backp, Scope))) { // The design is flattened and there are no useful scopes - // This is probably because of inilining + // This is probably because of inlining if (scopep->isTop()) break; str += scopep->prettyName(); diff --git a/src/V3Ast.h b/src/V3Ast.h index b2820535f..a3e49bd49 100644 --- a/src/V3Ast.h +++ b/src/V3Ast.h @@ -73,7 +73,7 @@ public: // enum en {...}; // const char* ascii() const {...}; enum en m_e; - // cppcheck-suppress uninitVar // responsiblity of each subclass + // cppcheck-suppress uninitVar // responsibility of each subclass inline AstType() {} // cppcheck-suppress noExplicitConstructor inline AstType(en _e) : m_e(_e) {} @@ -776,7 +776,7 @@ public: inline std::ostream& operator<<(std::ostream& os, const AstParseRefExp& rhs) { return os<littleEndian() : m.m_nrange.littleEndian()); } bool implicit() const { return keyword() == AstBasicDTypeKwd::LOGIC_IMPLICIT; } VNumRange declRange() const { return isRanged() ? VNumRange(msb(), lsb(), littleEndian()) : VNumRange(); } - void cvtRangeConst() { // Convert to smaller represenation + void cvtRangeConst() { // Convert to smaller representation if (rangep() && VN_IS(rangep()->msbp(), Const) && VN_IS(rangep()->lsbp(), Const)) { m.m_nrange.init(rangep()->msbConst(), rangep()->lsbConst(), rangep()->littleEndian()); @@ -3192,7 +3192,7 @@ public: ASTNODE_NODE_FUNCS(Repeat) AstNode* countp() const { return op2p(); } // op2 = condition to continue AstNode* bodysp() const { return op3p(); } // op3 = body of loop - virtual bool isGateOptimizable() const { return false; } // Not releavant - converted to FOR + virtual bool isGateOptimizable() const { return false; } // Not relevant - converted to FOR virtual int instrCount() const { return instrCountBranch(); } virtual V3Hash sameHash() const { return V3Hash(); } virtual bool same(const AstNode* samep) const { return true; } diff --git a/src/V3Case.cpp b/src/V3Case.cpp index 704fe015b..750ac3b37 100644 --- a/src/V3Case.cpp +++ b/src/V3Case.cpp @@ -210,7 +210,7 @@ private: return false; } } - if (m_caseItems <= 3) return false; // Not worth simplifing + if (m_caseItems <= 3) return false; // Not worth simplifying // Convert valueItem from AstCaseItem* to the expression // Not done earlier, as we may now have a NULL because it's just a ";" NOP branch for (uint32_t i=0; i<(1UL<b) would return wrong value, as - // less than has undeterministic signedness. + // less than has nondeterministic signedness. if (nodep->isQuad() && !nodep->lhsp()->isQuad() && !VN_IS(nodep->lhsp(), CCast)) { insertCast(nodep->lhsp(), VL_WORDSIZE); @@ -154,7 +154,7 @@ private: nodep->user1(1); } virtual void visit(AstConst* nodep) { - // Constants are of unknown size if smaller than 33 bits, becase + // Constants are of unknown size if smaller than 33 bits, because // we're too lazy to wrap every constant in the universe in // ((IData)#). nodep->user1(nodep->isQuad() || nodep->isWide()); diff --git a/src/V3Cdc.cpp b/src/V3Cdc.cpp index e8a9d823d..431d4db4c 100644 --- a/src/V3Cdc.cpp +++ b/src/V3Cdc.cpp @@ -682,7 +682,7 @@ private: } virtual void visit(AstSenGate* nodep) { // First handle the clock part will be handled in a minute by visit AstSenItem - // The logic gating term is delt with as logic + // The logic gating term is dealt with as logic iterateNewStmt(nodep); } virtual void visit(AstAssignAlias* nodep) { diff --git a/src/V3Clean.cpp b/src/V3Clean.cpp index 7379904d4..10240d912 100644 --- a/src/V3Clean.cpp +++ b/src/V3Clean.cpp @@ -72,7 +72,7 @@ private: int width = cppWidth(nodep); // widthMin is unchanged if (old_dtypep->width() != width) { // Since any given dtype's cppWidth() is the same, we can just - // remember one convertion for each, and reuse it + // remember one conversion for each, and reuse it if (AstNodeDType* new_dtypep = VN_CAST(old_dtypep->user3p(), NodeDType)) { nodep->dtypep(new_dtypep); } else { diff --git a/src/V3Clock.cpp b/src/V3Clock.cpp index cb92e2186..8eb28f003 100644 --- a/src/V3Clock.cpp +++ b/src/V3Clock.cpp @@ -301,7 +301,7 @@ private: changep), incp, NULL); // We could add another IF to detect posedges, and only increment if so. - // It's another whole branch though verus a potential memory miss. + // It's another whole branch though versus a potential memory miss. // We'll go with the miss. newp->addIfsp(new AstAssign(nodep->fileline(), changep->cloneTree(false), diff --git a/src/V3Combine.cpp b/src/V3Combine.cpp index 6b5d270a1..dbdad2c87 100644 --- a/src/V3Combine.cpp +++ b/src/V3Combine.cpp @@ -68,7 +68,7 @@ protected: // Note this is disabled, it still needed work // Also repair it for DPI functions; when make __common need to insure proper // flags get inherited from the old to new AstCFunc, and that AstText doesn't - // get split between functions causing the text to have a danginling reference. + // get split between functions causing the text to have a dangling reference. bool statementCombine() { return false; } // duplicateFunctionCombine(); }; diff --git a/src/V3Config.cpp b/src/V3Config.cpp index 35a65c7bd..973962429 100644 --- a/src/V3Config.cpp +++ b/src/V3Config.cpp @@ -35,7 +35,7 @@ class V3ConfigLine { public: int m_lineno; // Line number to make change at V3ErrorCode m_code; // Error code - bool m_on; // True to enaable message + bool m_on; // True to enable message V3ConfigLine(V3ErrorCode code, int lineno, bool on) : m_lineno(lineno), m_code(code), m_on(on) {} ~V3ConfigLine() {} diff --git a/src/V3Const.cpp b/src/V3Const.cpp index 9439f3b95..6c5cc6bb1 100644 --- a/src/V3Const.cpp +++ b/src/V3Const.cpp @@ -97,7 +97,7 @@ private: // AstJumpLabel::user4 -> bool. Set when AstJumpGo uses this label // STATE - bool m_params; // If true, propogate parameterized and true numbers only + bool m_params; // If true, propagate parameterized and true numbers only bool m_required; // If true, must become a constant bool m_wremove; // Inside scope, no assignw removal bool m_warn; // Output warnings @@ -557,7 +557,7 @@ private: return false; } bool concatMergeable(const AstNode* lhsp, const AstNode* rhsp) { - // determine if {a OP b, c OP d} => {a, c} OP {b, d} is advantagous + // determine if {a OP b, c OP d} => {a, c} OP {b, d} is advantageous if (!v3Global.opt.oAssemble()) return false; // opt disabled if (lhsp->type() != rhsp->type()) return false; if (!ifConcatMergeableBiop(lhsp)) return false; @@ -677,21 +677,21 @@ private: // NODE(..., CHILD(...)) -> CHILD(...) childp->unlinkFrBackWithNext(); // If replacing a SEL for example, the data type comes from the parent (is less wide). - // This may adversly affect the operation of the node being replaced. + // This may adversely affect the operation of the node being replaced. childp->dtypeFrom(nodep); nodep->replaceWith(childp); nodep->deleteTree(); VL_DANGLING(nodep); } //! Replace a ternary node with its RHS after iterating - //! Used with short-circuting, where the RHS has not yet been iterated. + //! Used with short-circuiting, where the RHS has not yet been iterated. void replaceWIteratedRhs(AstNodeTriop* nodep) { if (AstNode* rhsp = nodep->rhsp()) iterateAndNextNull(rhsp); replaceWChild(nodep, nodep->rhsp()); // May have changed } //! Replace a ternary node with its THS after iterating - //! Used with short-circuting, where the THS has not yet been iterated. + //! Used with short-circuiting, where the THS has not yet been iterated. void replaceWIteratedThs(AstNodeTriop* nodep) { if (AstNode* thsp = nodep->thsp()) iterateAndNextNull(thsp); replaceWChild(nodep, nodep->thsp()); // May have changed @@ -1658,7 +1658,7 @@ private: || VN_IS(nodep->sensp(), EnumItemRef) || (nodep->varrefp() && nodep->varrefp()->varp()->isParam()))) { // Constants in sensitivity lists may be removed (we'll simplify later) - if (nodep->isClocked()) { // A constant can never get a pos/negexge + if (nodep->isClocked()) { // A constant can never get a pos/negedge if (onlySenItemInSenTree(nodep)) { nodep->replaceWith(new AstSenItem(nodep->fileline(), AstSenItem::Never())); nodep->deleteTree(); VL_DANGLING(nodep); @@ -2192,7 +2192,7 @@ private: // v--- *1* These ops are always first, as we warn before replacing // v--- *V* This op is a verilog op, only in m_doV mode // v--- *C* This op works on all constant children, allowed in m_doConst mode - // v--- *S* This op specifies a type should use short-circuting of its lhs op + // v--- *S* This op specifies a type should use short-circuiting of its lhs op TREEOP1("AstSel{warnSelect(nodep)}", "NEVER"); // Generic constants on both side. Do this first to avoid other replacements @@ -2586,7 +2586,7 @@ AstNode* V3Const::constifyParamsEdit(AstNode* nodep) { //! trigger warnings when we deal with the width. It is possible that these //! are spurious, existing within sub-expressions that will not actually be //! generated. Since such occurrences, must be constant, in order to be -//! someting a generate block can depend on, we can wait until later to do the +//! something a generate block can depend on, we can wait until later to do the //! width check. //! @return Pointer to the edited node. AstNode* V3Const::constifyGenerateParamsEdit(AstNode* nodep) { diff --git a/src/V3Coverage.cpp b/src/V3Coverage.cpp index 75eb407ec..37bc5a81c 100644 --- a/src/V3Coverage.cpp +++ b/src/V3Coverage.cpp @@ -262,7 +262,7 @@ private: } } else if (AstUnionDType* adtypep = VN_CAST(dtypep, UnionDType)) { - // Arbitrarially handle only the first member of the union + // Arbitrarily handle only the first member of the union if (AstMemberDType* itemp = adtypep->membersp()) { AstNodeDType* subtypep = itemp->subDTypep()->skipRefp(); ToggleEnt newent (above.m_comment+string(".")+itemp->name(), diff --git a/src/V3Dead.cpp b/src/V3Dead.cpp index 9277de7e9..e88601f25 100644 --- a/src/V3Dead.cpp +++ b/src/V3Dead.cpp @@ -407,7 +407,7 @@ public: iterate(nodep); deadCheckVar(); - // We only elimate scopes when in a flattened structure + // We only eliminate scopes when in a flattened structure // Otherwise we have no easy way to know if a scope is used if (elimScopes) deadCheckScope(); if (elimCells) deadCheckCells(); diff --git a/src/V3Delayed.cpp b/src/V3Delayed.cpp index ce5ba9b83..06b7d3e10 100644 --- a/src/V3Delayed.cpp +++ b/src/V3Delayed.cpp @@ -99,7 +99,7 @@ private: AstAssignDly* m_nextDlyp; // Next delayed assignment in a list of assignments bool m_inDly; // True in delayed assignments bool m_inLoop; // True in for loops - bool m_inInitial; // True in intial blocks + bool m_inInitial; // True in initial blocks typedef std::map,AstVar*> VarMap; VarMap m_modVarMap; // Table of new var names created under module V3Double0 m_statSharedSet;// Statistic tracking diff --git a/src/V3Depth.cpp b/src/V3Depth.cpp index 6c7df0df6..e9db5be25 100644 --- a/src/V3Depth.cpp +++ b/src/V3Depth.cpp @@ -132,7 +132,7 @@ private: //-------------------- // Marking of non-static functions (because they might need "this") - // (Here instead of new vistor after V3Descope just to avoid another visitor) + // (Here instead of new visitor after V3Descope just to avoid another visitor) void needNonStaticFunc(AstNode* nodep) { UASSERT_OBJ(m_funcp, nodep, "Non-static accessor not under a function"); if (m_funcp->isStatic().trueU()) { diff --git a/src/V3Descope.cpp b/src/V3Descope.cpp index 9c7511885..0b64ba0b2 100644 --- a/src/V3Descope.cpp +++ b/src/V3Descope.cpp @@ -136,7 +136,7 @@ private: m_needThis = true; return name+"->"; } else { - // Reference to something elsewhere, or relative refences + // Reference to something elsewhere, or relative references // are disabled. Use global variable UINFO(8," Descope "<name()<fileline()->filename()); @@ -1865,7 +1865,7 @@ void EmitCImp::emitCtorImp(AstNodeModule* modp) { // // For example: suppose models A and B are each compiled to run on // 4 threads. The client might create a single thread pool with 3 - // threads and pass it to both models. If the client can ensure tht + // threads and pass it to both models. If the client can ensure that // A.eval() and B.eval() do NOT run concurrently, there will be no // contention for the threads. This mode is missing for now. (Is // there demand for such a setup?) @@ -3103,7 +3103,7 @@ class EmitCTrace : EmitCStmts { } // VISITORS - using EmitCStmts::visit; // Suppress hidden overloaded virtual function warnng + using EmitCStmts::visit; // Suppress hidden overloaded virtual function warning virtual void visit(AstNetlist* nodep) { // Top module only iterate(nodep->topModulep()); diff --git a/src/V3EmitCSyms.cpp b/src/V3EmitCSyms.cpp index 696bc3831..1d747220b 100644 --- a/src/V3EmitCSyms.cpp +++ b/src/V3EmitCSyms.cpp @@ -120,7 +120,7 @@ class EmitCSyms : EmitCBaseVisitor { } void varsExpand() { - // We didn'e have all m_scopes loaded when we encountered variables, so expand them now + // We didn't have all m_scopes loaded when we encountered variables, so expand them now // It would be less code if each module inserted its own variables. // Someday. For now public isn't common. for (std::vector::iterator itsc = m_scopes.begin(); diff --git a/src/V3Error.h b/src/V3Error.h index df1566b25..79088bee1 100644 --- a/src/V3Error.h +++ b/src/V3Error.h @@ -77,7 +77,7 @@ public: ENDLABEL, // End lable name mismatch GENCLK, // Generated Clock IFDEPTH, // If statements too deep - IGNOREDRETURN, // Ignoring return value (funcation as task) + IGNOREDRETURN, // Ignoring return value (function as task) IMPERFECTSCH, // Imperfect schedule (disabled by default) IMPLICIT, // Implicit wire IMPORTSTAR, // Import::* in $unit diff --git a/src/V3Expand.cpp b/src/V3Expand.cpp index 300abb673..cba63f41a 100644 --- a/src/V3Expand.cpp +++ b/src/V3Expand.cpp @@ -700,7 +700,7 @@ private: // Lhs or Rhs may be word, long, or quad. // newAstWordSelClone nicely abstracts the difference. int rhsshift = rhsp->rhsp()->widthMin(); - // Sometimes doing the words backwards is preferrable. + // Sometimes doing the words backwards is preferable. // When we have x={x,foo} backwards is better, when x={foo,x} forward is better // However V3Subst tends to rip this up, so not worth optimizing now. for (int w=0; wwidthWords(); w++) { diff --git a/src/V3File.cpp b/src/V3File.cpp index 61dad9b82..d657d57f3 100644 --- a/src/V3File.cpp +++ b/src/V3File.cpp @@ -179,7 +179,7 @@ inline void V3FileDependImp::writeTimes(const string& filename, const string& cm for (std::set::iterator iter=m_filenameList.begin(); iter!=m_filenameList.end(); ++iter) { // Read stats of files we create after we're done making them - // (execpt for this file, of course) + // (except for this file, of course) DependFile* dfp = const_cast(&(*iter)); V3Options::fileNfsFlush(dfp->filename()); dfp->loadStats(); diff --git a/src/V3Gate.cpp b/src/V3Gate.cpp index 48124de7b..45d2a0791 100644 --- a/src/V3Gate.cpp +++ b/src/V3Gate.cpp @@ -484,7 +484,7 @@ private: } virtual void visit(AstSenGate* nodep) { // First handle the clock part will be handled in a minute by visit AstSenItem - // The logic gating term is delt with as logic + // The logic gating term is dealt with as logic iterateNewStmt(nodep, "Clock gater", "Clock gater"); } virtual void visit(AstInitial* nodep) { diff --git a/src/V3GraphAcyc.cpp b/src/V3GraphAcyc.cpp index e98697ccf..a90e7bf83 100644 --- a/src/V3GraphAcyc.cpp +++ b/src/V3GraphAcyc.cpp @@ -169,7 +169,7 @@ private: UINFO(8," "<fromp()<<" ->"<top()<(vertexp); // Add vertex to list of nodes needing further optimization trials @@ -507,7 +507,7 @@ void GraphAcyc::placeTryEdge(V3GraphEdge* edgep) { edgep->cutable(true); // So graph still looks pretty cutOrigEdge(edgep, " Cut loop"); edgep->unlinkDelete(); VL_DANGLING(edgep); - // Backout the ranks we calculated + // Back out the ranks we calculated while (GraphAcycVertex* vertexp = workBeginp()) { workPop(); vertexp->rank(vertexp->m_storedRank); diff --git a/src/V3GraphDfa.cpp b/src/V3GraphDfa.cpp index f48abb712..87f9330f0 100644 --- a/src/V3GraphDfa.cpp +++ b/src/V3GraphDfa.cpp @@ -522,7 +522,7 @@ void DfaGraph::dfaReduce() { // this so we just create a edge for each case and mark it "complemented." // // 3. Delete temp vertex (old accept/new reject) and related edges. -// The user's old accept is now the new accept. This is imporant as +// The user's old accept is now the new accept. This is important as // we want the virtual type of it to be intact. class DfaGraphComplement : GraphAlg<> { diff --git a/src/V3GraphStream.h b/src/V3GraphStream.h index 8ab5dd8e3..92d937bdf 100644 --- a/src/V3GraphStream.h +++ b/src/V3GraphStream.h @@ -88,8 +88,8 @@ private: // MEMBERS VxHolderCmp m_vxHolderCmp; // Vertext comparison functor - ReadyVertices m_readyVertices; // List of ready verticies - WaitingVertices m_waitingVertices; // List of wiating verticies + ReadyVertices m_readyVertices; // List of ready vertices + WaitingVertices m_waitingVertices; // List of waiting vertices typename ReadyVertices::iterator m_last; // Previously returned element GraphWay m_way; // FORWARD or REVERSE order of traversal diff --git a/src/V3Inst.cpp b/src/V3Inst.cpp index 57ddadaf8..015e8a827 100644 --- a/src/V3Inst.cpp +++ b/src/V3Inst.cpp @@ -270,7 +270,7 @@ private: nodep->addNextHere(newp); // Remove ranging and fix name newp->rangep()->unlinkFrBack()->deleteTree(); - // Somewhat illogically, we need to rename the orignal name of the cell too. + // Somewhat illogically, we need to rename the original name of the cell too. // as that is the name users expect for dotting // The spec says we add [x], but that won't work in C... newp->name(newp->name()+"__BRA__"+cvtToStr(instNum)+"__KET__"); diff --git a/src/V3LinkDot.cpp b/src/V3LinkDot.cpp index 6d75fce16..7b3460461 100644 --- a/src/V3LinkDot.cpp +++ b/src/V3LinkDot.cpp @@ -332,7 +332,7 @@ public: VSymEnt* insertInline(VSymEnt* abovep, VSymEnt* modSymp, AstCellInline* nodep, const string& basename) { // A fake point in the hierarchy, corresponding to an inlined module - // This refrences to another Sym, and eventually resolves to a module with a prefix + // This references to another Sym, and eventually resolves to a module with a prefix UASSERT_OBJ(abovep, nodep, "Null symbol table inserting node"); VSymEnt* symp = new VSymEnt(&m_syms, nodep); UINFO(9," INSERTinl se"<fallbackp(oldCurSymp); // Convert the func's range to the output variable // This should probably be done in the Parser instead, as then we could - // just attact normal signal attributes to it. + // just attach normal signal attributes to it. if (nodep->fvarp() && !VN_IS(nodep->fvarp(), Var)) { AstNodeDType* dtypep = VN_CAST(nodep->fvarp(), NodeDType); diff --git a/src/V3LinkJump.cpp b/src/V3LinkJump.cpp index 880e5e9f9..ddd322e94 100644 --- a/src/V3LinkJump.cpp +++ b/src/V3LinkJump.cpp @@ -77,7 +77,7 @@ private: nodep->v3fatalSrc("Unknown jump point for break/disable/continue"); return NULL; } - // Skip over variables as we'll just move them in a momement + // Skip over variables as we'll just move them in a moment // Also this would otherwise prevent us from using a label twice // see t_func_return test. while (underp && VN_IS(underp, Var)) underp = underp->nextp(); diff --git a/src/V3LinkLevel.cpp b/src/V3LinkLevel.cpp index c7975816e..66dcfdf42 100644 --- a/src/V3LinkLevel.cpp +++ b/src/V3LinkLevel.cpp @@ -145,7 +145,7 @@ void V3LinkLevel::wrapTopCell(AstNetlist* rootp) { typedef vl_unordered_set NameSet; NameSet ioNames; NameSet dupNames; - // For all modulues, skipping over new top + // For all modules, skipping over new top for (AstNodeModule* oldmodp = VN_CAST(rootp->modulesp()->nextp(), NodeModule); oldmodp && oldmodp->level() <= 2; oldmodp = VN_CAST(oldmodp->nextp(), NodeModule)) { @@ -163,7 +163,7 @@ void V3LinkLevel::wrapTopCell(AstNetlist* rootp) { } } - // For all modulues, skipping over new top + // For all modules, skipping over new top for (AstNodeModule* oldmodp = VN_CAST(rootp->modulesp()->nextp(), NodeModule); oldmodp && oldmodp->level() <= 2; oldmodp = VN_CAST(oldmodp->nextp(), NodeModule)) { diff --git a/src/V3Number.cpp b/src/V3Number.cpp index 1a2721da5..c6f5addcc 100644 --- a/src/V3Number.cpp +++ b/src/V3Number.cpp @@ -650,7 +650,7 @@ string V3Number::toDecimalU() const { for (int nibble_bit = 0; nibble_bit < maxdecwidth; nibble_bit += 4) { if (bcd.bitsValue(nibble_bit, 4) >= 5) { tmp2.setAllBits0(); - tmp2.setBit(nibble_bit, 1); // Add 3, decompsed as two bits + tmp2.setBit(nibble_bit, 1); // Add 3, decomposed as two bits tmp2.setBit(nibble_bit+1, 1); tmp.opAssign(bcd); bcd.opAdd(tmp, tmp2); diff --git a/src/V3Options.cpp b/src/V3Options.cpp index b5f71eccd..a219f9e05 100644 --- a/src/V3Options.cpp +++ b/src/V3Options.cpp @@ -555,7 +555,7 @@ string V3Options::argString(int argc, char** argv) { void V3Options::parseOpts(FileLine* fl, int argc, char** argv) { // Parse all options - // Inital entry point from Verilator.cpp + // Initial entry point from Verilator.cpp parseOptsList(fl, ".", argc, argv); // Default certain options and error check diff --git a/src/V3Order.cpp b/src/V3Order.cpp index 03180383e..2d5adbd43 100644 --- a/src/V3Order.cpp +++ b/src/V3Order.cpp @@ -1071,7 +1071,7 @@ private: con = false; } if (varscp->varp()->attrClockEn() && !m_inPre && !m_inPost && !m_inClocked) { - // clock_enable attribute: user's worring about it for us + // clock_enable attribute: user's worrying about it for us con = false; } if (m_inClkAss && (varscp->varp()->attrClocker() @@ -1411,7 +1411,7 @@ void OrderVisitor::processInputsOutIterate(OrderEitherVertex* vertexp, VertexVec vertexp->user(3); // out-edges processed { - // Propagate PrimaryIn through simple assignments, followint target of vertex + // Propagate PrimaryIn through simple assignments, following target of vertex for (V3GraphEdge* edgep = vertexp->outBeginp(); edgep; edgep=edgep->outNextp()) { OrderEitherVertex* toVertexp = static_cast(edgep->top()); if (OrderVarStdVertex* vvertexp = dynamic_cast(toVertexp)) { diff --git a/src/V3Param.cpp b/src/V3Param.cpp index 84ad55b5f..9950d3920 100644 --- a/src/V3Param.cpp +++ b/src/V3Param.cpp @@ -464,7 +464,7 @@ private: } } - //! Parameter subsitution for generated for loops. + //! Parameter substitution for generated for loops. //! @todo Unlike generated IF, we don't have to worry about short-circuiting the conditional //! expression, since this is currently restricted to simple comparisons. If we ever do //! move to more generic constant expressions, such code will be needed here. diff --git a/src/V3Partition.cpp b/src/V3Partition.cpp index 80001e420..b55e15f6e 100644 --- a/src/V3Partition.cpp +++ b/src/V3Partition.cpp @@ -103,7 +103,7 @@ class MergeCandidate; // should cost almost nothing in terms of partitioner quality. // // If you want the most aggressive possible partition, set it "false" and -// be prepared to be dissappointed when the improvement in the partition is +// be prepared to be disappointed when the improvement in the partition is // negligible / in the noise. // // Q) Why retain the control, if there is really no downside? @@ -2204,7 +2204,7 @@ public: , m_ready(m_mtaskCmp) {} ~PartPackMTasks() {} - // METHOS + // METHODS uint32_t completionTime(const ExecMTask* mtaskp, uint32_t thread) { const MTaskState& state = m_mtaskState[mtaskp]; UASSERT(mtaskp->thread() != 0xffffffff, "Mtask should have assigned thread"); diff --git a/src/V3PreProc.cpp b/src/V3PreProc.cpp index 118be67c8..55149c181 100644 --- a/src/V3PreProc.cpp +++ b/src/V3PreProc.cpp @@ -156,7 +156,7 @@ public: string m_strify; ///< Text to be stringified // For defines - std::stack m_defRefs; ///< Pending definine substitution + std::stack m_defRefs; ///< Pending define substitution std::stack m_ifdefStack; ///< Stack of true/false emitting evaluations unsigned m_defDepth; ///< How many `defines deep bool m_defPutJoin; ///< Insert `` after substitution @@ -564,7 +564,7 @@ string V3PreProcImp::defineSubst(V3DefineRef* refp) { // and would make recursive definitions and parameter handling nasty. // // Note we parse the definition parameters and value here. If a - // parametrized define is used many, many times, we could cache the + // parameterized define is used many, many times, we could cache the // parsed result. UINFO(4,"defineSubstIn `"<name()<<" "<params()<args().size(); i++) { @@ -598,7 +598,7 @@ string V3PreProcImp::defineSubst(V3DefineRef* refp) { // Parse it if (argName!="") { if (refp->args().size() > numArgs) { - // A call `def( a ) must be equivelent to `def(a ), so trimWhitespace + // A call `def( a ) must be equivalent to `def(a ), so trimWhitespace // At one point we didn't trim trailing // whitespace, but this confuses `" string arg = trimWhitespace(refp->args()[numArgs], true); @@ -954,7 +954,7 @@ int V3PreProcImp::getStateToken() { if (tok==VP_DEFREF_JOIN) { // Here's something fun and unspecified as yet: - // The existance of non-existance of a base define changes `` expansion + // The existence of non-existance of a base define changes `` expansion // `define QA_b zzz // `define Q1 `QA``_b // 1Q1 -> zzz @@ -1048,7 +1048,7 @@ int V3PreProcImp::getStateToken() { else goto next_tok; } else if (tok==VP_DEFREF) { - // IE, `ifdef `MACRO(x): Substitue and come back here when state pops. + // IE, `ifdef `MACRO(x): Substitute and come back here when state pops. break; } else { @@ -1288,7 +1288,7 @@ int V3PreProcImp::getStateToken() { } else if (tok==VP_DEFREF) { // Spec says to expand macros inside `" - // Substitue it into the stream, then return here + // Substitute it into the stream, then return here break; } else { diff --git a/src/V3PreShell.cpp b/src/V3PreShell.cpp index 366c1a44a..47ed56691 100644 --- a/src/V3PreShell.cpp +++ b/src/V3PreShell.cpp @@ -107,7 +107,7 @@ protected: // Set language standard up front if (!v3Global.opt.preprocOnly()) { - // Leting lex parse this saves us from having to specially en/decode + // Letting lex parse this saves us from having to specially en/decode // from the V3LangCode to the various Lex BEGIN states. The language // of this source file is updated here, in case there have been any // intervening +ext+ options since it was first encountered. diff --git a/src/V3Premit.cpp b/src/V3Premit.cpp index 33c91910c..eb89c17ac 100644 --- a/src/V3Premit.cpp +++ b/src/V3Premit.cpp @@ -23,7 +23,7 @@ // For each wide OP, make a a temporary variable with the wide value // For each deep expression, assign expression to temporary. // -// Each display (independant transformation; here as Premit is a good point) +// Each display (independent transformation; here as Premit is a good point) // If autoflush, insert a flush // //************************************************************************* diff --git a/src/V3Scope.cpp b/src/V3Scope.cpp index d18dfc04b..c738d730e 100644 --- a/src/V3Scope.cpp +++ b/src/V3Scope.cpp @@ -65,7 +65,7 @@ private: PackageScopeMap m_packageScopes; // Scopes for each package VarScopeMap m_varScopes; // Varscopes created for each scope and var - VarRefScopeSet m_varRefScopes; // Varrefs-in-scopes needing fixup when donw + VarRefScopeSet m_varRefScopes; // Varrefs-in-scopes needing fixup when done // METHODS VL_DEBUG_FUNC; // Declare debug() diff --git a/src/V3Simulate.h b/src/V3Simulate.h index 55be4f73d..8ee3693cc 100644 --- a/src/V3Simulate.h +++ b/src/V3Simulate.h @@ -946,7 +946,7 @@ private: } // default - // These types are definately not reducable + // These types are definitely not reducible // AstCoverInc, AstArraySel, AstFinish, // AstRand, AstTime, AstUCFunc, AstCCall, AstCStmt, AstUCStmt virtual void visit(AstNode* nodep) { diff --git a/src/V3String.cpp b/src/V3String.cpp index f9a7c6532..8f4d5fe62 100644 --- a/src/V3String.cpp +++ b/src/V3String.cpp @@ -256,7 +256,7 @@ string VHashSha1::digestSymbol() { // Make a symbol name from hash. Similar to base64, however base 64 // has + and / for last two digits, but need C symbol, and we also // avoid conflicts with use of _, so use "AB" at the end. - // Thus this function is non-reversable. + // Thus this function is non-reversible. static const char digits[64+1] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AB"; const string& binhash = digestBinary(); diff --git a/src/V3String.h b/src/V3String.h index b09a08c0e..3ff018bc0 100644 --- a/src/V3String.h +++ b/src/V3String.h @@ -120,7 +120,7 @@ public: class VSpellCheck { // CONSTANTS enum { NUM_CANDIDATE_LIMIT = 10000 }; // Avoid searching huge netlists - enum { LENGTH_LIMIT = 100 }; // Maximum string length to seach + enum { LENGTH_LIMIT = 100 }; // Maximum string length to search // TYPES typedef unsigned int EditDistance; typedef std::vector Candidates; diff --git a/src/V3TSP.cpp b/src/V3TSP.cpp index 73fb9325b..d08fe7e3b 100644 --- a/src/V3TSP.cpp +++ b/src/V3TSP.cpp @@ -545,7 +545,7 @@ public: } virtual int cost(const TspTestState* otherp) const { // For test purposes, each TspTestState is merely a point - // on the cartesian plane; cost is the linear distance + // on the Cartesian plane; cost is the linear distance // between two points. unsigned xabs, yabs; xabs = diff(otherp->m_xpos, m_xpos); diff --git a/src/V3Table.cpp b/src/V3Table.cpp index acdc21984..9db3acec4 100644 --- a/src/V3Table.cpp +++ b/src/V3Table.cpp @@ -154,7 +154,7 @@ private: public: void simulateVarRefCb(AstVarRef* nodep) { - // Called by TableSimulateVisitor on each unique varref enountered + // Called by TableSimulateVisitor on each unique varref encountered UINFO(9," SimVARREF "<varScopep(); if (nodep->lvalue()) { @@ -283,7 +283,7 @@ private: // Create table // There may be a simulation path by which the output doesn't change value. // We could bail on these cases, or we can have a "change it" boolean. - // We've choosen the later route, since recirc is common in large FSMs. + // We've chosen the latter route, since recirc is common in large FSMs. for (std::deque::iterator it = m_outVarps.begin(); it != m_outVarps.end(); ++it) { m_outNotSet.push_back(false); diff --git a/src/V3TraceDecl.cpp b/src/V3TraceDecl.cpp index e0fa66dd8..e925c26bb 100644 --- a/src/V3TraceDecl.cpp +++ b/src/V3TraceDecl.cpp @@ -197,7 +197,7 @@ private: addIgnore("Wide memory > --trace-max-array ents"); } else if (VN_IS(nodep->subDTypep()->skipRefp(), BasicDType) // Nothing lower than this array && m_traVscp->dtypep()->skipRefp() == nodep) { // Nothing above this array - // Simple 1-D array, use exising V3EmitC runtime loop rather than unrolling + // Simple 1-D array, use existing V3EmitC runtime loop rather than unrolling // This will put "(index)" at end of signal name for us if (m_traVscp->dtypep()->skipRefp()->isString()) { addIgnore("Unsupported: strings"); diff --git a/src/V3Tristate.cpp b/src/V3Tristate.cpp index 4ce368067..aa0392442 100644 --- a/src/V3Tristate.cpp +++ b/src/V3Tristate.cpp @@ -925,7 +925,7 @@ class TristateVisitor : public TristateBaseVisitor { UINFO(9,dbgState()<=9) nodep->dumpTree(cout, "-assign: "); // if the rhsp of this assign statement has an output enable driver, - // then propage the corresponding output enable assign statement. + // then propagate the corresponding output enable assign statement. // down the lvalue tree by recursion for eventual attachment to // the appropriate output signal's VarRef. if (nodep->rhsp()->user1p()) { @@ -1031,7 +1031,7 @@ class TristateVisitor : public TristateBaseVisitor { // the complexity of merging tristate drivers at any level, the // current limitation of this implementation is that a pullup/down // gets applied to all bits of a bus and a bus cannot have drivers - // in opposite directions on indvidual pins. + // in opposite directions on individual pins. varrefp->lvalue(true); m_tgraph.didProcess(nodep); m_tgraph.didProcess(varrefp->varp()); @@ -1261,7 +1261,7 @@ class TristateVisitor : public TristateBaseVisitor { && m_tgraph.isTristate(nodep->varp()) // and in a position where it feeds upstream to another tristate && m_tgraph.feedsTri(nodep)) { - // Then propage the enable from the original variable + // Then propagate the enable from the original variable UINFO(9," Ref-to-tri "<varp()); nodep->user1p(new AstVarRef(nodep->fileline(), enVarp, false)); diff --git a/src/V3Undriven.cpp b/src/V3Undriven.cpp index b3e1cb183..6743611cc 100644 --- a/src/V3Undriven.cpp +++ b/src/V3Undriven.cpp @@ -238,7 +238,7 @@ private: std::vector m_entryps[3]; // Nodes to delete when we are finished bool m_inBBox; // In black box; mark as driven+used bool m_inContAssign; // In continuous assignment - bool m_inProcAssign; // In procedual assignment + bool m_inProcAssign; // In procedural assignment AstNodeFTask* m_taskp; // Current task AstAlways* m_alwaysCombp; // Current always if combo, otherwise NULL diff --git a/src/V3Width.cpp b/src/V3Width.cpp index 41ef4116a..6dcf2083b 100644 --- a/src/V3Width.cpp +++ b/src/V3Width.cpp @@ -4230,7 +4230,7 @@ AstNode* V3Width::widthParamsEdit(AstNode* nodep) { //! trigger warnings when we deal with the width. It is possible that //! these are spurious, existing within sub-expressions that will not //! actually be generated. Since such occurrences, must be constant, in -//! order to be someting a generate block can depend on, we can wait until +//! order to be something a generate block can depend on, we can wait until //! later to do the width check. //! @return Pointer to the edited node. AstNode* V3Width::widthGenerateParamsEdit( diff --git a/src/V3WidthSel.cpp b/src/V3WidthSel.cpp index 886740dc7..f80e792ea 100644 --- a/src/V3WidthSel.cpp +++ b/src/V3WidthSel.cpp @@ -393,7 +393,7 @@ private: // How to recover? We'll strip a dimension. nodep->replaceWith(fromp); pushDeletep(nodep); VL_DANGLING(nodep); } - // delete whataver we didn't use in reconstruction + // delete whatever we didn't use in reconstruction if (!fromp->backp()) { pushDeletep(fromp); VL_DANGLING(fromp); } if (!msbp->backp()) { pushDeletep(msbp); VL_DANGLING(msbp); } if (!lsbp->backp()) { pushDeletep(lsbp); VL_DANGLING(lsbp); } @@ -465,7 +465,7 @@ private: // How to recover? We'll strip a dimension. nodep->replaceWith(fromp); pushDeletep(nodep); VL_DANGLING(nodep); } - // delete whataver we didn't use in reconstruction + // delete whatever we didn't use in reconstruction if (!fromp->backp()) { pushDeletep(fromp); VL_DANGLING(fromp); } if (!rhsp->backp()) { pushDeletep(rhsp); VL_DANGLING(rhsp); } if (!widthp->backp()) { pushDeletep(widthp); VL_DANGLING(widthp); }