Index: src/func.c
==================================================================
--- src/func.c
+++ src/func.c
@@ -1951,11 +1951,11 @@
   }
 }
 
 /*
 ** On some systems, ceil() and floor() are intrinsic function.  You are
-** unable to take a pointer to this functions.  Hence, we here wrap them
+** unable to take a pointer to these functions.  Hence, we here wrap them
 ** in our own actual functions.
 */
 static double xCeil(double x){ return ceil(x); }
 static double xFloor(double x){ return floor(x); }
 

Index: tool/lemon.c
==================================================================
--- tool/lemon.c
+++ tool/lemon.c
@@ -399,11 +399,11 @@
   struct symbol **symbols; /* Sorted array of pointers to symbols */
   int errorcnt;            /* Number of errors */
   struct symbol *errsym;   /* The error symbol */
   struct symbol *wildcard; /* Token that matches anything */
   char *name;              /* Name of the generated parser */
-  char *arg;               /* Declaration of the 3th argument to parser */
+  char *arg;               /* Declaration of the 3rd argument to parser */
   char *ctx;               /* Declaration of 2nd argument to constructor */
   char *tokentype;         /* Type of terminal symbols in the parser stack */
   char *vartype;           /* The default type of non-terminal symbols */
   char *start;             /* Name of the start symbol for the grammar */
   char *stacksize;         /* Size of the parser stack */
@@ -1025,11 +1025,11 @@
   struct config *newcfg;  /* */
   struct symbol *sp;   /* Symbol following the dot in configuration "cfp" */
   struct symbol *bsp;  /* Symbol following the dot in configuration "bcfp" */
   struct state *newstp; /* A pointer to a successor state */
 
-  /* Each configuration becomes complete after it contibutes to a successor
+  /* Each configuration becomes complete after it contributes to a successor
   ** state.  Initially, all configurations are incomplete */
   for(cfp=stp->cfp; cfp; cfp=cfp->next) cfp->status = INCOMPLETE;
 
   /* Loop through all configurations of the state "stp" */
   for(cfp=stp->cfp; cfp; cfp=cfp->next){
@@ -1541,11 +1541,11 @@
   lemon_strcpy(*paz, z);
   for(z=*paz; *z && *z!='='; z++){}
   *z = 0;
 }
 
-/* Rember the name of the output directory 
+/* Remember the name of the output directory 
 */
 static char *outputDir = NULL;
 static void handle_d_option(char *z){
   outputDir = (char *) malloc( lemonStrlen(z)+1 );
   if( outputDir==0 ){
@@ -1885,11 +1885,11 @@
 **   next:      Pointer to pointer to the second element of the list.
 **   cmp:       A comparison function.
 **
 ** Return Value:
 **   A pointer to the head of a sorted list containing the elements
-**   orginally in list.
+**   originally in list.
 **
 ** Side effects:
 **   The "next" pointers for elements in list are changed.
 */
 #define LISTSIZE 30
@@ -3511,11 +3511,11 @@
   fclose(fp);
   return;
 }
 
 /* Search for the file "name" which is in the same directory as
-** the exacutable */
+** the executable */
 PRIVATE char *pathsearch(char *argv0, char *name, int modemask)
 {
   const char *pathlist;
   char *pathbufptr = 0;
   char *pathbuf = 0;
@@ -3866,11 +3866,11 @@
   if( rp->nrhs==0 ){
     /* If there are no RHS symbols, then writing directly to the LHS is ok */
     lhsdirect = 1;
   }else if( rp->rhsalias[0]==0 ){
     /* The left-most RHS symbol has no value.  LHS direct is ok.  But
-    ** we have to call the distructor on the RHS symbol first. */
+    ** we have to call the destructor on the RHS symbol first. */
     lhsdirect = 1;
     if( has_destructor(rp->rhs[0],lemp) ){
       append_str(0,0,0,0);
       append_str("  yy_destructor(yypParser,%d,&yymsp[%d].minor);\n", 0,
                  rp->rhs[0]->index,1-rp->nrhs);
@@ -4847,11 +4847,11 @@
 
   /* Generate the tables of rule information.  yyRuleInfoLhs[] and
   ** yyRuleInfoNRhs[].
   **
   ** Note: This code depends on the fact that rules are number
-  ** sequentually beginning with 0.
+  ** sequentially beginning with 0.
   */
   for(i=0, rp=lemp->rule; rp; rp=rp->next, i++){
     fprintf(out,"  %4d,  /* (%d) ", rp->lhs->index, i);
      rule_print(out, rp);
     fprintf(out," */\n"); lineno++;