Index: tool/lemon.c
==================================================================
--- tool/lemon.c
+++ tool/lemon.c
@@ -489,18 +489,20 @@
 **
 ** Return the offset into the action table of the new transaction.
 */
 int acttab_insert(acttab *p){
   int i, j, k, n;
+  int nActtab;     /* Number of slots in the p->aAction[] table */
   assert( p->nLookahead>0 );
 
   /* Make sure we have enough space to hold the expanded action table
   ** in the worst case.  The worst case occurs if the transaction set
   ** must be appended to the current action table
   */
   n = p->mxLookahead + 1;
-  if( p->nAction + n >= p->nActionAlloc ){
+  nActtab = p->nAction + n;
+  if( nActtab >= p->nActionAlloc ){
     int oldAlloc = p->nActionAlloc;
     p->nActionAlloc = p->nAction + n + p->nActionAlloc + 20;
     p->aAction = realloc( p->aAction,
                           sizeof(p->aAction[0])*p->nActionAlloc);
     if( p->aAction==0 ){
@@ -514,15 +516,15 @@
   }
 
   /* Scan the existing action table looking for an offset where we can
   ** insert the current transaction set.  Fall out of the loop when that
   ** offset is found.  In the worst case, we fall out of the loop when
-  ** i reaches p->nAction, which means we append the new transaction set.
+  ** i reaches nActtab, which means we append the new transaction set.
   **
   ** i is the index in p->aAction[] where p->mnLookahead is inserted.
   */
-  for(i=p->nAction-1; i>=0; i--){
+  for(i=nActtab-1; i>=0; i--){
     /* First look for an existing action table entry that can be reused */
     if( p->aAction[i].lookahead==p->mnLookahead ){
       if( p->aAction[i].action!=p->mnAction ) continue;
       for(j=0; j<p->nLookahead; j++){
         k = p->aLookahead[j].lookahead - p->mnLookahead + i;
@@ -541,11 +543,11 @@
       }
     }
   }
   if( i<0 ){
     /* If no reusable entry is found, look for an empty slot */
-    for(i=0; i<p->nAction; i++){
+    for(i=0; i<nActtab; i++){
       if( p->aAction[i].lookahead<0 ){
         for(j=0; j<p->nLookahead; j++){
           k = p->aLookahead[j].lookahead - p->mnLookahead + i;
           if( k<0 ) break;
           if( p->aAction[k].lookahead>=0 ) break;