Many typo's

These were found using the command below searching for duplicated words,
and manually going through the results to remove the false positives and
reword the true positives. Sometimes I removed the doubled word and
sometimes I replaced the duplicated word.

The grep command:
grep -nIEr '\b([a-zA-Z]+)[[:space:]*]+\1\b' ./Ghidra

Ghidra/Features/Decompiler/src/decompile/cpp/action.hh

@@ -136,7 +136,7 @@ public:
 
 /// \brief A group of actions (generally) applied in sequence
 ///
-/// This is a a list of Action objects, which are usually applied in sequence.
+/// This is a list of Action objects, which are usually applied in sequence.
 /// But the behavior properties of each individual Action may affect this.
 /// Properties (like rule_repeatapply) may be put directly to this group
 /// that also affect how the Actions are applied.

Ghidra/Features/Decompiler/src/decompile/cpp/address.hh

@@ -16,7 +16,7 @@
 /// \file address.hh
 /// \brief Classes for specifying addresses and other low-level constants
 ///
-///  All addresses are absolute and there are are no registers in CPUI. However,
+///  All addresses are absolute and there are no registers in CPUI. However,
 ///  all addresses are prefixed with an "immutable" pointer, which can
 ///  specify a separate RAM space, a register space, an i/o space etc. Thus
 ///  a translation from a real machine language will typically simulate registers

Ghidra/Features/Decompiler/src/decompile/cpp/architecture.cc

@@ -1166,7 +1166,7 @@ ProtoModel *Architecture::createUnknownModel(const string &modelName)
   return model;
 }
 
-/// This looks for the \<processor_spec> tag and and sets configuration
+/// This looks for the \<processor_spec> tag and sets configuration
 /// parameters based on it.
 /// \param store is the document store holding the tag
 void Architecture::parseProcessorConfig(DocumentStorage &store)

Ghidra/Features/Decompiler/src/decompile/cpp/block.cc

@@ -398,7 +398,7 @@ bool FlowBlock::dominates(const FlowBlock *subBlock) const
 /// We assume the given block has 2 out-edges and that \b this block is immediately reached by
 /// one of these two edges. Some condition holds when traversing the out-edge to \b this, and the complement
 /// of the condition holds for traversing the other out-edge. We verify that the condition holds for
-/// this entire block.  More specifically, we check that that there is no path to \b this through the
+/// this entire block.  More specifically, we check that there is no path to \b this through the
 /// sibling edge, where the complement of the condition holds (unless we loop back through the conditional block).
 /// \param cond is the conditional block with 2 out-edges
 /// \return \b true if the condition holds for this block
@@ -3479,7 +3479,7 @@ void BlockSwitch::addCase(FlowBlock *switchbl,FlowBlock *bl,uint4 gt)
 void BlockSwitch::grabCaseBasic(FlowBlock *switchbl,const vector<FlowBlock *> &cs)
 
 {
-  vector<int4> casemap(switchbl->sizeOut(),-1);	// Map from from switchtarget's outindex to position in caseblocks
+  vector<int4> casemap(switchbl->sizeOut(),-1);	// Map from switchtarget's outindex to position in caseblocks
   caseblocks.clear();
   for(int4 i=1;i<cs.size();++i) {
     FlowBlock *casebl = cs[i];

Ghidra/Features/Decompiler/src/decompile/cpp/blockaction.hh

@@ -163,7 +163,7 @@ class TraceDAG {
   FlowBlock *finishblock;		///< Designated exit block for the DAG (or null)
   void removeTrace(BlockTrace *trace);	///< Remove the indicated BlockTrace
   void processExitConflict(list<BadEdgeScore>::iterator start,list<BadEdgeScore>::iterator end);
-  BlockTrace *selectBadEdge(void);	///< Select the the most likely unstructured edge from active BlockTraces
+  BlockTrace *selectBadEdge(void);	///< Select the most likely unstructured edge from active BlockTraces
   void insertActive(BlockTrace *trace);	///< Move a BlockTrace into the \e active category
   void removeActive(BlockTrace *trace);	///< Remove a BlockTrace from the \e active category
   bool checkOpen(BlockTrace *trace);	///< Check if we can push the given BlockTrace into its next node

Ghidra/Features/Decompiler/src/decompile/cpp/constseq.cc

@@ -177,8 +177,8 @@ uint4 ArraySequence::selectStringCopyFunction(int4 &index)
 /// \brief Set-up for recovering COPY ops into a memory range, given a Symbol and an Address being COPYed into
 ///
 /// The SymbolEntry and Address are passed in, with an expected data-type.  Check if there is an array
-/// of the data-type within the Symbol, and if so, initialize the memory range for the the sequence.
-/// Follow on with gathering PcodeOps and testing if the sequence is viable.  If not, the the size the memory
+/// of the data-type within the Symbol, and if so, initialize the memory range for the sequence.
+/// Follow on with gathering PcodeOps and testing if the sequence is viable.  If not, the size of the memory
 /// range will be set to zero.
 /// \param fdata is the function containing the root COPY
 /// \param ct is the specific data-type for which there should be an array

Ghidra/Features/Decompiler/src/decompile/cpp/database.cc

@@ -61,7 +61,7 @@ SymbolEntry::SymbolEntry(Symbol *sym)
 /// is set to \e invalid, and the \b hash becomes the primary location information.
 /// \param sym is the underlying Symbol
 /// \param exfl are the Varnode flags associated with the storage location
-/// \param h is the the hash
+/// \param h is the hash
 /// \param off if the offset into the Symbol for this (piece of) storage
 /// \param sz is the size in bytes of this (piece of) storage
 /// \param rnglist is the set of code addresses where \b this SymbolEntry represents the Symbol

Ghidra/Features/Decompiler/src/decompile/cpp/database.hh

@@ -713,7 +713,7 @@ public:
 
   /// \brief Restore attributes for \b this from a parent element that is not a Scope
   ///
-  /// Attributes are read from the (already opened) element, prior to reading reading the
+  /// Attributes are read from the (already opened) element, prior to reading the
   /// \<scope> element specific to \b this Scope
   /// \param decoder is the stream decoder
   virtual void decodeWrappingAttributes(Decoder &decoder) {}

Ghidra/Features/Decompiler/src/decompile/cpp/fspec.cc

@@ -206,7 +206,7 @@ bool ParamEntry::containedBy(const Address &addr,int4 sz) const
   return (entryoff <= rangeoff);
 }
 
-/// If \b this a a \e join, each piece is tested for intersection.
+/// If \b this is a \e join, each piece is tested for intersection.
 /// Otherwise, \b this, considered as a single memory, is tested for intersection.
 /// \param addr is the starting address of the given memory range to test against
 /// \param sz is the number of bytes in the given memory range

Ghidra/Features/Decompiler/src/decompile/cpp/funcdata_varnode.cc

@@ -1724,7 +1724,7 @@ void Funcdata::prepareThisPointer(void)
       return;		// Data-type will be obtained directly from symbol
   }
 
-  // Its possible that a recommendation for the "this" pointer has already been been collected.
+  // It's possible that a recommendation for the "this" pointer has already been collected.
   // Currently the only type recommendations are for the "this" pointer. If there any, it is for "this"
   if (localmap->hasTypeRecommendations())
     return;

Ghidra/Features/Decompiler/src/decompile/cpp/heritage.cc

@@ -1083,7 +1083,7 @@ bool Heritage::discoverIndexedStackPointers(AddrSpace *spc,vector<PcodeOp *> &fr
 	      // If there were no traversals (of non-constant ADD or MULTIEQUAL) then the
 	      // pointer is equal to the stackpointer plus a constant (through an indirect is possible)
 	      // This will likely get resolved in the next heritage pass, but we leave the
-	      // spacebaseptr mark on, so that that the indirects don't get removed
+	      // spacebaseptr mark on, so the indirects don't get removed
 	      fd->opMarkSpacebasePtr(op);
 	    }
 	  }

Ghidra/Features/Decompiler/src/decompile/cpp/merge.cc

@@ -801,7 +801,7 @@ void Merge::collectInputs(HighVariable *high,vector<PcodeOpNode> &oplist,PcodeOp
   }
 }
 
-/// \brief Snip instances of the output of an INDIRECT that are also inputs to to the underlying PcodeOp
+/// \brief Snip instances of the output of an INDIRECT that are also inputs to the underlying PcodeOp
 ///
 /// Examine the output HighVariable for the given INDIRECT op. Varnode instances (or pieces) that are also
 /// inputs to the underlying PcodeOp causing the INDIRECT are snipped by creating a new COPY op from the

Ghidra/Features/Decompiler/src/decompile/cpp/prettyprint.hh

@@ -440,7 +440,7 @@ public:
 
   /// \brief Set a pending print callback
   ///
-  /// The callback will be issued prior to the the next call to tagLine() unless
+  /// The callback will be issued prior to the next call to tagLine() unless
   /// a the method cancelPendingPrint() is called first.
   /// \param pend is the callback to be issued
   void setPendingPrint(PendPrint *pend) { pendPrint = pend; }

Ghidra/Features/Decompiler/src/decompile/cpp/printc.hh

@@ -361,7 +361,7 @@ public:
 ///
 /// When a variable has TypePointerRel as its data-type, PTRSUB acts relative to the \e parent
 /// data-type.  We print a specific token to indicate this relative shift is happening.
-/// \param op is is the PTRSUB op
+/// \param op is the PTRSUB op
 inline void PrintC::pushTypePointerRel(const PcodeOp *op)
 
 {

Ghidra/Features/Decompiler/src/decompile/cpp/rangeutil.cc

@@ -200,7 +200,7 @@ CircleRange::CircleRange(bool val)
 
 /// A size specifies the number of bytes (*8 to get number of bits) in the mask.
 /// The stride is assumed to be 1.
-/// \param val is is the single value
+/// \param val is the single value
 /// \param size is the size of the mask in bytes
 CircleRange::CircleRange(uintb val,int4 size)
 
@@ -228,7 +228,7 @@ void CircleRange::setRange(uintb lft,uintb rgt,int4 size,int4 stp)
 
 /// A size specifies the number of bytes (*8 to get number of bits) in the mask.
 /// The stride is assumed to be 1.
-/// \param val is is the single value
+/// \param val is the single value
 /// \param size is the size of the mask in bytes
 void CircleRange::setRange(uintb val,int4 size)
 

Ghidra/Features/Decompiler/src/decompile/cpp/ruleaction.cc

@@ -6176,7 +6176,7 @@ bool AddTreeState::checkTerm(Varnode *vn,uint8 treeCoeff)
 
 /// Recursively walk the sub-tree from the given root.
 /// Terms that are a \e multiple of the base data-type size are accumulated either in
-/// the the sum of constant multiples or the container of non-constant multiples.
+/// the sum of constant multiples or the container of non-constant multiples.
 /// Terms that are a \e non-multiple are accumulated either in the sum of constant
 /// non-multiples or the container of non-constant non-multiples. The constant
 /// non-multiples are counted twice, once in the sum, and once in the container.

Ghidra/Features/Decompiler/src/decompile/cpp/stringmanage.hh

@@ -42,7 +42,7 @@ protected:
   /// \brief String data (a sequence of bytes) stored by StringManager
   class StringData {
   public:
-    bool isTruncated;		///< \b true if the the string is truncated
+    bool isTruncated;		///< \b true if the string is truncated
     vector<uint1> byteData;	///< UTF8 encoded string data
   };
   map<Address,StringData> stringMap;	///< Map from address to string data

Ghidra/Features/Decompiler/src/decompile/cpp/subflow.cc

@@ -2582,7 +2582,7 @@ void SplitDatatype::buildOutConcats(Varnode *rootVn,PcodeOp *previousOp,vector<V
     data.getMerge().registerProtoPartialRoot(rootVn);
 }
 
-/// \brief Build a a series of PTRSUB ops at different offsets, given a root pointer
+/// \brief Build a series of PTRSUB ops at different offsets, given a root pointer
 ///
 /// Offsets and data-types are based on \b dataTypePieces, taking input data-types if \b isInput is \b true,
 /// output data-types otherwise.  The data-types, relative to the root pointer, are assumed to start at

Ghidra/Features/Decompiler/src/decompile/cpp/type.hh

@@ -192,7 +192,7 @@ protected:
   string name;			///< Name of type
   string displayName;		///< Name to display in output
   type_metatype metatype;	///< Meta-type - type disregarding size
-  sub_metatype submeta;		///< Sub-type of of the meta-type, for comparisons
+  sub_metatype submeta;		///< Sub-type of the meta-type, for comparisons
   Datatype *typedefImm;		///< The immediate data-type being typedefed by \e this
   int4 alignment;		///< Byte alignment expected for \b this data-type in addressable memory
   int4 alignSize;		///< Size of data-type rounded up to a multiple of \b alignment