Spelling src

These are non-functional changes.

* accounting
* activation
* actual
* added
* addresult
* aggregable
* aligned
* alternatively
* ambiguous
* analysis
* analyzer
* anticlimactic
* apparently
* application
* appropriate
* arithmetic
* assignment
* assigns
* associated
* authentication
* authoritative
* barrier
* boundary
* broccoli
* buffering
* caching
* called
* canonicalized
* capturing
* certificates
* ciphersuite
* columns
* communication
* comparison
* comparisons
* compilation
* component
* concatenating
* concatenation
* connection
* convenience
* correctly
* corresponding
* could
* counting
* data
* declared
* decryption
* defining
* dependent
* deprecated
* detached
* dictionary
* directional
* directly
* directory
* discarding
* disconnecting
* distinguishes
* documentation
* elsewhere
* emitted
* empty
* endianness
* endpoint
* enumerator
* essentially
* evaluated
* everything
* exactly
* execute
* explicit
* expressions
* facilitates
* fiddling
* filesystem
* flag
* flagged
* for
* fragments
* guarantee
* guaranteed
* happen
* happening
* hemisphere
* identifier
* identifies
* identify
* implementation
* implemented
* implementing
* including
* inconsistency
* indeterminate
* indices
* individual
* information
* initial
* initialization
* initialize
* initialized
* initializes
* instantiate
* instantiated
* instantiates
* interface
* internal
* interpreted
* interpreter
* into
* it
* iterators
* length
* likely
* log
* longer
* mainly
* mark
* maximum
* message
* minimum
* module
* must
* name
* namespace
* necessary
* nonexistent
* not
* notifications
* notifier
* number
* objects
* occurred
* operations
* original
* otherwise
* output
* overridden
* override
* overriding
* overwriting
* ownership
* parameters
* particular
* payload
* persistent
* potential
* precision
* preexisting
* preservation
* preserved
* primarily
* probably
* procedure
* proceed
* process
* processed
* processes
* processing
* propagate
* propagated
* prototype
* provides
* publishing
* purposes
* queue
* reached
* reason
* reassem
* reassemble
* reassembler
* recommend
* record
* reduction
* reference
* regularly
* representation
* request
* reserved
* retrieve
* returning
* separate
* should
* shouldn't
* significant
* signing
* simplified
* simultaneously
* single
* somebody
* sources
* specific
* specification
* specified
* specifies
* specify
* statement
* subdirectories
* succeeded
* successful
* successfully
* supplied
* synchronization
* tag
* temporarily
* terminating
* that
* the
* transmitted
* true
* truncated
* try
* understand
* unescaped
* unforwarding
* unknown
* unknowndata
* unspecified
* update
* usually
* which
* wildcard

Signed-off-by: Josh Soref <2119212+jsoref@users.noreply.github.com>

src/script_opt/CPP/Compile.h

@@ -10,7 +10,7 @@
 #include "zeek/script_opt/ScriptOpt.h"
 
 // We structure the compiler for generating C++ versions of Zeek script
-// bodies maily as a single large class.  While we divide the compiler's
+// bodies mainly as a single large class.  While we divide the compiler's
 // functionality into a number of groups (see below), these interact with
 // one another, and in particular with various member variables, enough
 // so that it's not clear there's benefit to further splitting the
@@ -385,7 +385,7 @@ private:
 	// then the BiF is also used in a non-call context.
 	void AddBiF(const ID* b, bool is_var);
 
-	// Register the given global name.  "suffix" distinguishs particular
+	// Register the given global name.  "suffix" distinguishes particular
 	// types of globals, such as the names of bifs, global (non-function)
 	// variables, or compiled Zeek functions.
 	bool AddGlobal(const std::string& g, const char* suffix);
@@ -413,7 +413,7 @@ private:
 	std::string LocalName(const IDPtr& l) const { return LocalName(l.get()); }
 
 	// Returns a canonicalized name, with various non-alphanumeric
-	// characters stripped or transformed, and guananteed not to
+	// characters stripped or transformed, and guaranteed not to
 	// conflict with C++ keywords.
 	std::string Canonicalize(const char* name) const;
 
@@ -509,7 +509,7 @@ private:
 	                      const IDPList* lambda_ids, const ProfileFunc* pf);
 
 	// Inspects the given profile to find the i'th parameter (starting
-	// at 0).  Returns nil if the profile indicates that that parameter
+	// at 0).  Returns nil if the profile indicates that the parameter
 	// is not used by the function.
 	const ID* FindParam(int i, const ProfileFunc* pf);
 
@@ -595,7 +595,7 @@ private:
 	std::unordered_set<std::string> compiled_funcs;
 
 	// "Simple" functions that we've compiled, i.e., those that have
-	// a single body and thus can be called dirctly.  Indexed by
+	// a single body and thus can be called directly.  Indexed by
 	// function name, and maps to the C++ name.
 	std::unordered_map<std::string, std::string> compiled_simple_funcs;
 

src/script_opt/CPP/Exprs.cc

@@ -1088,7 +1088,7 @@ string CPPCompile::GenAssign(const ExprPtr& lhs, const ExprPtr& rhs, const strin
 			return GenListAssign(lhs, rhs);
 
 		default:
-			reporter->InternalError("bad assigment node in CPPCompile::GenExpr");
+			reporter->InternalError("bad assignment node in CPPCompile::GenExpr");
 			return "XXX";
 		}
 	}

src/script_opt/CPP/InitsInfo.h

@@ -217,7 +217,7 @@ private:
 class CPP_BasicConstInitsInfo : public CPP_CustomInitsInfo
 	{
 public:
-	// In the following, if "c_type" is non-empty then it specifes the
+	// In the following, if "c_type" is non-empty then it specifies the
 	// C++ type used to directly represent the constant.  If empty, it
 	// indicates that we instead use an index into a separate vector.
 	CPP_BasicConstInitsInfo(std::string _tag, std::string type, std::string c_type)
@@ -519,7 +519,7 @@ protected:
 	std::string wrapper_class;
 	};
 
-// Information for registering the class/function assocaited with a lambda.
+// Information for registering the class/function associated with a lambda.
 class LambdaRegistrationInfo : public CPP_InitInfo
 	{
 public:

src/script_opt/CPP/RuntimeInits.h

@@ -52,7 +52,7 @@ public:
 		{
 		}
 
-	// Providse generic access to Zeek constant values based on a single
+	// Provides generic access to Zeek constant values based on a single
 	// index.
 	ValPtr ConstVals(int offset) const
 		{

src/script_opt/CPP/RuntimeOps.cc

@@ -157,7 +157,7 @@ SubNetValPtr addr_mask__CPP(const IPAddr& a, uint32_t mask)
 	return make_intrusive<SubNetVal>(a, mask);
 	}
 
-// Helper function for reporting invalidation of interators.
+// Helper function for reporting invalidation of iterators.
 static void check_iterators__CPP(bool invalid)
 	{
 	if ( invalid )
@@ -208,7 +208,7 @@ void remove_element__CPP(TableValPtr aggr, ListValPtr indices)
 // A helper function that takes a parallel vectors of attribute tags
 // and values and returns a collective AttributesPtr corresponding to
 // those instantiated attributes.  For attributes that don't have
-// associated expressions, the correspoinding value should be nil.
+// associated expressions, the corresponding value should be nil.
 static AttributesPtr build_attrs__CPP(vector<int> attr_tags, vector<ValPtr> attr_vals)
 	{
 	vector<AttrPtr> attrs;