Fix typos in C comments inside storage/

Author: qobood

storage/archive/azio.c

@@ -215,7 +215,7 @@ int write_header(azio_stream *s)
  int8store(ptr + AZ_CHECK_POS, (unsigned long long)s->check_point); /* Start of Data Block Index Block */
  int8store(ptr + AZ_AUTOINCREMENT_POS, (unsigned long long)s->auto_increment); /* Start of Data Block Index Block */
  int4store(ptr+ AZ_LONGEST_POS , s->longest_row); /* Longest row */
- int4store(ptr+ AZ_SHORTEST_POS, s->shortest_row); /* Shorest row */
+ int4store(ptr+ AZ_SHORTEST_POS, s->shortest_row); /* Shortest row */
  int4store(ptr+ AZ_FRM_POS, 
  AZHEADER_SIZE + AZMETA_BUFFER_SIZE); /* FRM position */
  *(ptr + AZ_DIRTY_POS)= (unsigned char)s->dirty; /* Start of Data Block Index Block */

storage/archive/ha_archive.cc

@@ -41,8 +41,8 @@
  
  We keep a file pointer open for each instance of ha_archive for each read
  but for writes we keep one open file handle just for that. We flush it
- only if we have a read occur. azip handles compressing lots of records
- at once much better then doing lots of little records between writes.
+ only if we have a read occur. azio handles compressing lots of records
+ at once much better than doing lots of little records between writes.
  It is possible to not lock on writes but this would then mean we couldn't
  handle bulk inserts as well (that is if someone was trying to read at
  the same time since we would want to flush).
@@ -60,7 +60,7 @@
 
  At some point a recovery method for such a drastic case needs to be divised.
 
- Locks are row level, and you will get a consistant read. 
+ Locks are row level, and you will get a consistent read.
 
  For performance as far as table scans go it is quite fast. I don't have
  good numbers but locally it has out performed both Innodb and MyISAM. For
@@ -1010,7 +1010,7 @@ int ha_archive::write_row(const uchar *buf)
  temp_auto= table->next_number_field->val_int();
 
  /*
- We don't support decremening auto_increment. They make the performance
+ We don't support decrementing auto_increment. They make the performance
  just cry.
  */
  if (temp_auto <= share->archive_write.auto_increment && 

storage/archive/ha_archive.h

@@ -52,7 +52,7 @@ class Archive_share : public Handler_share
 /*
  Version for file format.
  1 - Initial Version (Never Released)
- 2 - Stream Compression, seperate blobs, no packing
+ 2 - Stream Compression, separate blobs, no packing
  3 - One stream (row and blobs), with packing
 */
 #define ARCHIVE_VERSION 3

storage/connect/array.h

@@ -107,7 +107,7 @@ class DllExport ARRAY : public XOBJECT, public CSORT { // Array descblock
 /* This class is used when constructing the arrays of constants used */
 /* for indexing. Its only purpose is to provide a way to sort, reduce */
 /* and reorder the arrays of multicolumn indexes as one block. Indeed */
-/* sorting the arrays independantly would break the correspondance of */
+/* sorting the arrays independently would break the correspondence of */
 /* column values. */
 /***********************************************************************/
 class MULAR : public CSORT, public BLOCK { // No need to be an XOBJECT

storage/connect/csort.cpp

@@ -95,7 +95,7 @@ CSORT::CSORT(bool cns, int th, int mth)
  } // end of CSORT constructor
 
 /***********************************************************************/
-/* CSORT intialization.  */
+/* CSORT initialization. */
 /***********************************************************************/
 int CSORT::Qsort(PGLOBAL g, int nb)
  {

storage/connect/filamgz.cpp

@@ -339,7 +339,7 @@ int GZFAM::ReadBuffer(PGLOBAL g)
  *p = '\0'; // Eliminate ending new-line character
 
  if (*(--p) == '\r')
- *p = '\0'; // Eliminate eventuel carriage return
+ *p = '\0'; // Eliminate eventual carriage return
 
  strcpy(Tdbp->GetLine(), To_Buf);
  IsRead = true;

storage/connect/filamtxt.cpp

@@ -352,7 +352,7 @@ int TXTFAM::StoreValues(PGLOBAL g, bool upd)
 /* record are not necessarily updated in sequential order. */
 /* Moving intermediate lines cannot be done while making them because */
 /* this can cause extra wrong records to be included in the new file. */
-/* What we do here is to reorder the updated records and do all the */
+/* What we do here is reorder the updated records and do all the  */
 /* updates ordered by record position. */
 /***********************************************************************/
 int TXTFAM::UpdateSortedRows(PGLOBAL g)
@@ -402,7 +402,7 @@ int TXTFAM::UpdateSortedRows(PGLOBAL g)
 /***********************************************************************/
 /* DeleteSortedRows. When deleting using indexing, the issue is that */
 /* record are not necessarily deleted in sequential order. Moving */
-/* intermediate lines cannot be done while deleing them because  */
+/* intermediate lines cannot be done while deleting them because */
 /* this can cause extra wrong records to be included in the new file. */
 /* What we do here is to reorder the deleted record and delete from */
 /* the file from the ordered deleted records. */

storage/connect/filter.cpp

@@ -547,7 +547,7 @@ bool FILTER::FindJoinFilter(POPJOIN opj, PFIL fprec, bool teq, bool tek,
  return (Opc < 0);
 
  // Keep only equi-joins and specific joins (Outer and Distinct)
- // Normally specific join operators comme first because they have
+ // Normally specific join operators come first because they have
  // been placed first by SortJoin.
  if (teq && Opc > OP_EQ)
  return FALSE;
@@ -747,7 +747,7 @@ bool FILTER::CheckHaving(PGLOBAL g, PSQL sqlp)
  return FALSE;
  default:
  if (CheckColumn(g, sqlp, xp, agg) < -1)
- return TRUE; // Unrecovable error
+ return TRUE; // Unrecoverable error
 
  break;
  } // endswitch Opc

storage/connect/fmdlex.c

@@ -845,7 +845,7 @@ static int yy_get_next_buffer()
  { /* Don't try to fill the buffer, so this is an EOF. */
  if ( yy_c_buf_p - yytext_ptr - YY_MORE_ADJ == 1 )
  {
- /* We matched a singled characater, the EOB, so
+ /* We matched a singled character, the EOB, so
  * treat this as a final EOF.
  */
  return EOB_ACT_END_OF_FILE;

storage/connect/ha_connect.cc

@@ -4990,7 +4990,7 @@ int ha_connect::external_lock(THD *thd, int lock_type)
  } // endelse Xchk
 
  if (CloseTable(g)) {
- // This is an error while builing index
+ // This is an error while building index
  // Make it a warning to avoid crash
  push_warning(thd, Sql_condition::WARN_LEVEL_WARN, ER_UNKNOWN_ERROR, g->Message);
  rc= 0;