style: s/lookahead_tokens/lookaheads/g

Currently we use both names.  Let's stick to the short one.

* src/AnnotationList.c, src/conflicts.c, src/counterexample.c,
* src/getargs.c, src/getargs.h, src/graphviz.c, src/ielr.c,
* src/lalr.c, src/print-graph.c, src/print-xml.c, src/print.c,
* src/state-item.c, src/state.c, src/state.h, src/tables.c:
s/lookahead_token/lookahead/gi.

16 files changed, 104 insertions, 107 deletions

diff --git a/src/AnnotationList.c b/src/AnnotationList.c
index 421643b2..92b6690f 100644
--- a/src/AnnotationList.c
+++ b/src/AnnotationList.c
@@ -169,10 +169,10 @@ AnnotationList__compute_conflicted_tokens (bitset shift_tokens,
   bitset_copy (tokens, shift_tokens);
   for (int i = 0; i < reds->num; ++i)
     {
-      bitset_and (conflicted_tokens_rule, tokens, reds->lookahead_tokens[i]);
+      bitset_and (conflicted_tokens_rule, tokens, reds->lookaheads[i]);
       bitset_or (conflicted_tokens,
                  conflicted_tokens, conflicted_tokens_rule);
-      bitset_or (tokens, tokens, reds->lookahead_tokens[i]);
+      bitset_or (tokens, tokens, reds->lookaheads[i]);
       /* Check that rules are sorted on rule number or the next step in
          AnnotationList__compute_from_inadequacies will misbehave.  */
       aver (i == 0 || reds->rules[i-1] < reds->rules[i]);
@@ -401,7 +401,7 @@ AnnotationList__compute_from_inadequacies (
   struct obstack *annotations_obstackp,
   InadequacyListNodeCount *inadequacy_list_node_count)
 {
-  /* Return an empty list if s->lookahead_tokens = NULL.  */
+  /* Return an empty list if s->lookaheads = NULL.  */
   if (s->consistent)
     return;
 
@@ -422,7 +422,7 @@ AnnotationList__compute_from_inadequacies (
       /* Allocate the annotation node.  */
       {
         for (int rule_i = 0; rule_i < s->reductions->num; ++rule_i)
-          if (bitset_test (s->reductions->lookahead_tokens[rule_i],
+          if (bitset_test (s->reductions->lookaheads[rule_i],
                            conflicted_token))
             ++contribution_count;
         if (bitset_test (shift_tokens, conflicted_token))
@@ -445,7 +445,7 @@ AnnotationList__compute_from_inadequacies (
         for (int rule_i = 0; rule_i < s->reductions->num; ++rule_i)
           {
             rule *the_rule = s->reductions->rules[rule_i];
-            if (bitset_test (s->reductions->lookahead_tokens[rule_i],
+            if (bitset_test (s->reductions->lookaheads[rule_i],
                              conflicted_token))
               {
                 bitset_set (actions, rule_i);
diff --git a/src/conflicts.c b/src/conflicts.c
index f33f1b1b..b6307358 100644
--- a/src/conflicts.c
+++ b/src/conflicts.c
@@ -250,9 +250,9 @@ flush_shift (state *s, int token)
 `--------------------------------------------------------------------*/
 
 static void
-flush_reduce (bitset lookahead_tokens, int token)
+flush_reduce (bitset lookaheads, int token)
 {
-  bitset_reset (lookahead_tokens, token);
+  bitset_reset (lookaheads, token);
 }
 
 
@@ -275,10 +275,10 @@ resolve_sr_conflict (state *s, int ruleno, symbol **errors, int *nerrs)
   /* Find the rule to reduce by to get precedence of reduction.  */
   rule *redrule = reds->rules[ruleno];
   int redprec = redrule->prec->prec;
-  bitset lookahead_tokens = reds->lookahead_tokens[ruleno];
+  bitset lookaheads = reds->lookaheads[ruleno];
 
   for (symbol_number i = 0; i < ntokens; ++i)
-    if (bitset_test (lookahead_tokens, i)
+    if (bitset_test (lookaheads, i)
         && bitset_test (lookahead_set, i)
         && symbols[i]->content->prec)
       {
@@ -295,7 +295,7 @@ resolve_sr_conflict (state *s, int ruleno, symbol **errors, int *nerrs)
           {
             register_precedence (i, redrule->prec->number);
             log_resolution (redrule, i, shift_resolution);
-            flush_reduce (lookahead_tokens, i);
+            flush_reduce (lookaheads, i);
           }
         else
           /* Matching precedence levels.
@@ -316,7 +316,7 @@ resolve_sr_conflict (state *s, int ruleno, symbol **errors, int *nerrs)
             case right_assoc:
               register_assoc (i, redrule->prec->number);
               log_resolution (redrule, i, right_resolution);
-              flush_reduce (lookahead_tokens, i);
+              flush_reduce (lookaheads, i);
               break;
 
             case left_assoc:
@@ -329,7 +329,7 @@ resolve_sr_conflict (state *s, int ruleno, symbol **errors, int *nerrs)
               register_assoc (i, redrule->prec->number);
               log_resolution (redrule, i, nonassoc_resolution);
               flush_shift (s, i);
-              flush_reduce (lookahead_tokens, i);
+              flush_reduce (lookaheads, i);
               /* Record an explicit error for this token.  */
               errors[(*nerrs)++] = symbols[i];
               break;
@@ -369,7 +369,7 @@ set_conflicts (state *s, symbol **errors)
   for (int i = 0; i < reds->num; ++i)
     if (reds->rules[i]->prec
         && reds->rules[i]->prec->prec
-        && !bitset_disjoint_p (reds->lookahead_tokens[i], lookahead_set))
+        && !bitset_disjoint_p (reds->lookaheads[i], lookahead_set))
       resolve_sr_conflict (s, i, errors, &nerrs);
 
   if (nerrs)
@@ -385,13 +385,13 @@ set_conflicts (state *s, symbol **errors)
   /* Loop over all rules which require lookahead in this state.  Check
      for conflicts not resolved above.
 
-     reds->lookahead_tokens can be NULL if the LR type is LR(0).  */
-  if (reds->lookahead_tokens)
+     reds->lookaheads can be NULL if the LR type is LR(0).  */
+  if (reds->lookaheads)
     for (int i = 0; i < reds->num; ++i)
       {
-        if (!bitset_disjoint_p (reds->lookahead_tokens[i], lookahead_set))
+        if (!bitset_disjoint_p (reds->lookaheads[i], lookahead_set))
           conflicts[s->number] = true;
-        bitset_or (lookahead_set, lookahead_set, reds->lookahead_tokens[i]);
+        bitset_or (lookahead_set, lookahead_set, reds->lookaheads[i]);
       }
 }
 
@@ -460,7 +460,7 @@ count_state_sr_conflicts (const state *s)
   }
 
   for (int i = 0; i < reds->num; ++i)
-    bitset_or (lookahead_set, lookahead_set, reds->lookahead_tokens[i]);
+    bitset_or (lookahead_set, lookahead_set, reds->lookaheads[i]);
 
   bitset_and (lookahead_set, lookahead_set, shift_set);
 
@@ -499,7 +499,7 @@ count_state_rr_conflicts (const state *s)
     {
       int count = 0;
       for (int j = 0; j < reds->num; ++j)
-        count += bitset_test (reds->lookahead_tokens[j], i);
+        count += bitset_test (reds->lookaheads[j], i);
       if (2 <= count)
         res += count-1;
     }
@@ -534,7 +534,7 @@ count_rule_state_sr_conflicts (rule *r, state *s)
   for (int i = 0; i < reds->num; ++i)
     if (reds->rules[i] == r)
       {
-        bitset lookaheads = reds->lookahead_tokens[i];
+        bitset lookaheads = reds->lookaheads[i];
         int j;
         FOR_EACH_SHIFT (trans, j)
           res += bitset_test (lookaheads, TRANSITION_SYMBOL (trans, j));
@@ -576,8 +576,8 @@ count_rule_state_rr_conflicts (rule *r, state *s)
         if (reds->rules[j] != r)
           {
             bitset_and (lookaheads,
-                        reds->lookahead_tokens[i],
-                        reds->lookahead_tokens[j]);
+                        reds->lookaheads[i],
+                        reds->lookaheads[j]);
             res += bitset_count (lookaheads);
           }
   bitset_free (lookaheads);
diff --git a/src/counterexample.c b/src/counterexample.c
index adb13caa..6735cd45 100644
--- a/src/counterexample.c
+++ b/src/counterexample.c
@@ -1286,7 +1286,7 @@ counterexample_report_state (const state *s, FILE *out, const char *prefix)
 {
   const state_number sn = s->number;
   const reductions *reds = s->reductions;
-  bitset lookahead_tokens = bitset_create (ntokens, BITSET_FIXED);
+  bitset lookaheads = bitset_create (ntokens, BITSET_FIXED);
   for (int i = 0; i < reds->num; ++i)
     {
       const rule *r1 = reds->rules[i];
@@ -1296,25 +1296,25 @@ counterexample_report_state (const state *s, FILE *out, const char *prefix)
           {
             item_number conf = *state_items[c2].item;
             if (item_number_is_symbol_number (conf)
-                && bitset_test (reds->lookahead_tokens[i], conf))
+                && bitset_test (reds->lookaheads[i], conf))
               counterexample_report_shift_reduce (c1, c2, conf, out, prefix);
           }
       for (int j = i+1; j < reds->num; ++j)
         {
           const rule *r2 = reds->rules[j];
           // Conflicts: common lookaheads.
-          bitset_intersection (lookahead_tokens,
-                               reds->lookahead_tokens[i],
-                               reds->lookahead_tokens[j]);
-          if (!bitset_empty_p (lookahead_tokens))
+          bitset_intersection (lookaheads,
+                               reds->lookaheads[i],
+                               reds->lookaheads[j]);
+          if (!bitset_empty_p (lookaheads))
             for (state_item_number c2 = state_item_map[sn]; c2 < state_item_map[sn + 1]; ++c2)
               if (!SI_DISABLED (c2)
                   && item_rule (state_items[c2].item) == r2)
                 {
-                  counterexample_report_reduce_reduce (c1, c2, lookahead_tokens, out, prefix);
+                  counterexample_report_reduce_reduce (c1, c2, lookaheads, out, prefix);
                   break;
                 }
         }
     }
-  bitset_free (lookahead_tokens);
+  bitset_free (lookaheads);
 }
diff --git a/src/getargs.c b/src/getargs.c
index f6c4d182..a15c07b5 100644
--- a/src/getargs.c
+++ b/src/getargs.c
@@ -221,7 +221,7 @@ static const argmatch_report_arg argmatch_report_args[] =
   { "none",            report_none },
   { "states",          report_states },
   { "itemsets",        report_states | report_itemsets },
-  { "lookaheads",      report_states | report_lookahead_tokens },
+  { "lookaheads",      report_states | report_lookaheads },
   { "solved",          report_states | report_solved_conflicts },
   { "counterexamples", report_cex },
   { "cex",             report_cex },
diff --git a/src/getargs.h b/src/getargs.h
index 8c47fa58..53826687 100644
--- a/src/getargs.h
+++ b/src/getargs.h
@@ -77,7 +77,7 @@ enum report
     report_none             = 0,
     report_states           = 1 << 0,
     report_itemsets         = 1 << 1,
-    report_lookahead_tokens = 1 << 2,
+    report_lookaheads       = 1 << 2,
     report_solved_conflicts = 1 << 3,
     report_cex              = 1 << 4,
     report_all              = ~0
diff --git a/src/graphviz.c b/src/graphviz.c
index 34d80b03..e75bbb19 100644
--- a/src/graphviz.c
+++ b/src/graphviz.c
@@ -184,9 +184,9 @@ output_red (state const *s, reductions const *reds, FILE *fout)
       bool firste = true;
       rule_number ruleno = reds->rules[j]->number;
 
-      if (reds->lookahead_tokens)
+      if (reds->lookaheads)
         for (int i = 0; i < ntokens; i++)
-          if (bitset_test (reds->lookahead_tokens[j], i))
+          if (bitset_test (reds->lookaheads[j], i))
             {
               if (bitset_test (no_reduce_set, i))
                 firstd = print_token (&dout, firstd, symbols[i]->tag);
diff --git a/src/ielr.c b/src/ielr.c
index 89e37fe4..11e4375a 100644
--- a/src/ielr.c
+++ b/src/ielr.c
@@ -1025,7 +1025,7 @@ ielr_split_states (bitsetv follow_kernel_items, bitsetv always_follows,
               {
                 rule *this_rule = node->state->reductions->rules[r];
                 bitset lookahead_set =
-                  node->state->reductions->lookahead_tokens[r];
+                  node->state->reductions->lookaheads[r];
                 if (item_number_is_rule_number (*this_rule->rhs))
                   ielr_compute_goto_follow_set (follow_kernel_items,
                                                 always_follows, node,
diff --git a/src/lalr.c b/src/lalr.c
index c6e096c8..0f5d7147 100644
--- a/src/lalr.c
+++ b/src/lalr.c
@@ -256,9 +256,9 @@ lookback_find_state (int lookback_index)
   state *res = NULL;
   for (int j = 0; j < nstates; ++j)
     if (states[j]->reductions
-        && states[j]->reductions->lookahead_tokens)
+        && states[j]->reductions->lookaheads)
       {
-        if (states[j]->reductions->lookahead_tokens - LA > lookback_index)
+        if (states[j]->reductions->lookaheads - LA > lookback_index)
           /* Went too far. */
           break;
         else
@@ -280,7 +280,7 @@ lookback_print (FILE *out)
     {
       fprintf (out, "   %3d = ", i);
       const state *s = lookback_find_state (i);
-      int rnum = i - (s->reductions->lookahead_tokens - LA);
+      int rnum = i - (s->reductions->lookaheads - LA);
       const rule *r = s->reductions->rules[rnum];
       fprintf (out, "(%3d, ", s->number);
       rule_print (r, NULL, out);
@@ -305,7 +305,7 @@ static void
 add_lookback_edge (state *s, rule const *r, goto_number gotono)
 {
   int ri = state_reduction_find (s, r);
-  int idx = (s->reductions->lookahead_tokens - LA) + ri;
+  int idx = (s->reductions->lookaheads - LA) + ri;
   lookback[idx] = goto_list_new (gotono, lookback[idx]);
 }
 
@@ -421,7 +421,7 @@ compute_follows (void)
 
 
 static void
-compute_lookahead_tokens (void)
+compute_lookaheads (void)
 {
   if (trace_flag & trace_automaton)
       lookback_print (stderr);
@@ -437,13 +437,12 @@ compute_lookahead_tokens (void)
 }
 
 
-/*----------------------------------------------------.
-| Count the number of lookahead tokens required for S |
-| (N_LOOKAHEAD_TOKENS member).                        |
-`----------------------------------------------------*/
+/*------------------------------------------------------.
+| Count the number of lookahead tokens required for S.  |
+`------------------------------------------------------*/
 
 static int
-state_lookahead_tokens_count (state *s, bool default_reduction_only_for_accept)
+state_lookaheads_count (state *s, bool default_reduction_only_for_accept)
 {
   const reductions *reds = s->reductions;
   const transitions *trans = s->transitions;
@@ -473,9 +472,9 @@ state_lookahead_tokens_count (state *s, bool default_reduction_only_for_accept)
 }
 
 
-/*----------------------------------------------------.
-| Compute LA, NLA, and the lookahead_tokens members.  |
-`----------------------------------------------------*/
+/*----------------------------------------------.
+| Compute LA, NLA, and the lookaheads members.  |
+`----------------------------------------------*/
 
 void
 initialize_LA (void)
@@ -491,25 +490,23 @@ initialize_LA (void)
   /* Compute the total number of reductions requiring a lookahead.  */
   nLA = 0;
   for (state_number i = 0; i < nstates; ++i)
-    nLA +=
-      state_lookahead_tokens_count (states[i],
-                                    default_reduction_only_for_accept);
+    nLA += state_lookaheads_count (states[i],
+                                   default_reduction_only_for_accept);
   /* Avoid having to special case 0.  */
   if (!nLA)
     nLA = 1;
 
   bitsetv pLA = LA = bitsetv_create (nLA, ntokens, BITSET_FIXED);
 
-  /* Initialize the members LOOKAHEAD_TOKENS for each state whose reductions
+  /* Initialize the members LOOKAHEADS for each state whose reductions
      require lookahead tokens.  */
   for (state_number i = 0; i < nstates; ++i)
     {
-      int count =
-        state_lookahead_tokens_count (states[i],
-                                      default_reduction_only_for_accept);
+      int count = state_lookaheads_count (states[i],
+                                          default_reduction_only_for_accept);
       if (count)
         {
-          states[i]->reductions->lookahead_tokens = pLA;
+          states[i]->reductions->lookaheads = pLA;
           pLA += count;
         }
     }
@@ -521,7 +518,7 @@ initialize_LA (void)
 `---------------------------------------------*/
 
 static void
-lookahead_tokens_print (FILE *out)
+lookaheads_print (FILE *out)
 {
   fputs ("Lookaheads:\n", out);
   for (state_number i = 0; i < nstates; ++i)
@@ -533,11 +530,11 @@ lookahead_tokens_print (FILE *out)
           for (int j = 0; j < reds->num; ++j)
             {
               fprintf (out, "    rule %d:", reds->rules[j]->number);
-              if (reds->lookahead_tokens)
+              if (reds->lookaheads)
               {
                 bitset_iterator iter;
                 int k;
-                BITSET_FOR_EACH (iter, reds->lookahead_tokens[j], k, 0)
+                BITSET_FOR_EACH (iter, reds->lookaheads[j], k, 0)
                   fprintf (out, " %s", symbols[k]->tag);
               }
               fputc ('\n', out);
@@ -564,10 +561,10 @@ lalr (void)
   lookback = xcalloc (nLA, sizeof *lookback);
   build_relations ();
   compute_follows ();
-  compute_lookahead_tokens ();
+  compute_lookaheads ();
 
   if (trace_flag & trace_sets)
-    lookahead_tokens_print (stderr);
+    lookaheads_print (stderr);
   if (trace_flag & trace_automaton)
     {
       begin_use_class ("trace0", stderr);
@@ -614,6 +611,6 @@ void
 lalr_free (void)
 {
   for (state_number s = 0; s < nstates; ++s)
-    states[s]->reductions->lookahead_tokens = NULL;
+    states[s]->reductions->lookaheads = NULL;
   bitsetv_free (LA);
 }
diff --git a/src/print-graph.c b/src/print-graph.c
index f99555aa..48836f26 100644
--- a/src/print-graph.c
+++ b/src/print-graph.c
@@ -96,7 +96,7 @@ print_core (struct obstack *oout, state *s)
         obstack_sgrow (oout, " %empty");
 
       /* Experimental feature: display the lookahead tokens. */
-      if (report_flag & report_lookahead_tokens
+      if (report_flag & report_lookaheads
           && item_number_is_rule_number (*sp1))
         {
           /* Find the reduction we are handling.  */
@@ -104,13 +104,13 @@ print_core (struct obstack *oout, state *s)
           int redno = state_reduction_find (s, r);
 
           /* Print them if there are.  */
-          if (reds->lookahead_tokens && redno != -1)
+          if (reds->lookaheads && redno != -1)
             {
               bitset_iterator biter;
               int k;
               char const *sep = "";
               obstack_sgrow (oout, "  [");
-              BITSET_FOR_EACH (biter, reds->lookahead_tokens[redno], k, 0)
+              BITSET_FOR_EACH (biter, reds->lookaheads[redno], k, 0)
                 {
                   obstack_sgrow (oout, sep);
                   obstack_backslash (oout, symbols[k]->tag);
diff --git a/src/print-xml.c b/src/print-xml.c
index bd231045..2f1ad5b1 100644
--- a/src/print-xml.c
+++ b/src/print-xml.c
@@ -86,12 +86,12 @@ print_core (FILE *out, int level, state *s)
           reductions *reds = s->reductions;
           int red = state_reduction_find (s, r);
           /* Print item with lookaheads if there are. */
-          if (reds->lookahead_tokens && red != -1)
+          if (reds->lookaheads && red != -1)
             {
               xml_printf (out, level + 1,
                           "<item rule-number=\"%d\" dot=\"%d\">",
                           r->number, sp1 - sp);
-              state_rule_lookahead_tokens_print_xml (s, r,
+              state_rule_lookaheads_print_xml (s, r,
                                                      out, level + 2);
               xml_puts (out, level + 1, "</item>");
               printed = true;
@@ -203,25 +203,25 @@ print_errs (FILE *out, int level, state *s)
 
 
 /*-------------------------------------------------------------------------.
-| Report a reduction of RULE on LOOKAHEAD_TOKEN (which can be 'default').  |
+| Report a reduction of RULE on LOOKAHEAD (which can be 'default').  |
 | If not ENABLED, the rule is masked by a shift or a reduce (S/R and       |
 | R/R conflicts).                                                          |
 `-------------------------------------------------------------------------*/
 
 static void
-print_reduction (FILE *out, int level, char const *lookahead_token,
+print_reduction (FILE *out, int level, char const *lookahead,
                  rule *r, bool enabled)
 {
   if (r->number)
     xml_printf (out, level,
                 "<reduction symbol=\"%s\" rule=\"%d\" enabled=\"%s\"/>",
-                xml_escape (lookahead_token),
+                xml_escape (lookahead),
                 r->number,
                 enabled ? "true" : "false");
   else
     xml_printf (out, level,
                 "<reduction symbol=\"%s\" rule=\"accept\" enabled=\"%s\"/>",
-                xml_escape (lookahead_token),
+                xml_escape (lookahead),
                 enabled ? "true" : "false");
 }
 
@@ -258,13 +258,13 @@ print_reductions (FILE *out, int level, state *s)
   if (default_reduction)
     report = true;
 
-  if (reds->lookahead_tokens)
+  if (reds->lookaheads)
     for (i = 0; i < ntokens; i++)
       {
         bool count = bitset_test (no_reduce_set, i);
 
         for (j = 0; j < reds->num; ++j)
-          if (bitset_test (reds->lookahead_tokens[j], i))
+          if (bitset_test (reds->lookaheads[j], i))
             {
               if (! count)
                 {
@@ -289,14 +289,14 @@ print_reductions (FILE *out, int level, state *s)
   xml_puts (out, level, "<reductions>");
 
   /* Report lookahead tokens (or $default) and reductions.  */
-  if (reds->lookahead_tokens)
+  if (reds->lookaheads)
     for (i = 0; i < ntokens; i++)
       {
         bool defaulted = false;
         bool count = bitset_test (no_reduce_set, i);
 
         for (j = 0; j < reds->num; ++j)
-          if (bitset_test (reds->lookahead_tokens[j], i))
+          if (bitset_test (reds->lookaheads[j], i))
             {
               if (! count)
                 {
diff --git a/src/print.c b/src/print.c
index 257eef25..7aba2189 100644
--- a/src/print.c
+++ b/src/print.c
@@ -90,9 +90,9 @@ print_core (FILE *out, const state *s)
       previous_rule = r;
 
       /* Display the lookahead tokens?  */
-      if (report_flag & report_lookahead_tokens
+      if (report_flag & report_lookaheads
           && item_number_is_rule_number (*sp1))
-        state_rule_lookahead_tokens_print (s, r, out);
+        state_rule_lookaheads_print (s, r, out);
       fputc ('\n', out);
     }
 }
@@ -181,18 +181,18 @@ print_errs (FILE *out, const state *s)
 
 
 /*-------------------------------------------------------------------------.
-| Report a reduction of RULE on LOOKAHEAD_TOKEN (which can be 'default').  |
+| Report a reduction of RULE on LOOKAHEAD (which can be 'default').  |
 | If not ENABLED, the rule is masked by a shift or a reduce (S/R and       |
 | R/R conflicts).                                                          |
 `-------------------------------------------------------------------------*/
 
 static void
 print_reduction (FILE *out, size_t width,
-                 const char *lookahead_token,
+                 const char *lookahead,
                  rule *r, bool enabled)
 {
-  fprintf (out, "    %s", lookahead_token);
-  for (int j = width - mbswidth (lookahead_token, 0); j > 0; --j)
+  fprintf (out, "    %s", lookahead);
+  for (int j = width - mbswidth (lookahead, 0); j > 0; --j)
     fputc (' ', out);
   if (!enabled)
     fputc ('[', out);
@@ -239,13 +239,13 @@ print_reductions (FILE *out, const state *s)
   if (default_reduction)
     width = mbswidth (_("$default"), 0);
 
-  if (reds->lookahead_tokens)
+  if (reds->lookaheads)
     for (int i = 0; i < ntokens; i++)
       {
         bool count = bitset_test (no_reduce_set, i);
 
         for (int j = 0; j < reds->num; ++j)
-          if (bitset_test (reds->lookahead_tokens[j], i))
+          if (bitset_test (reds->lookaheads[j], i))
             {
               if (! count)
                 {
@@ -268,7 +268,7 @@ print_reductions (FILE *out, const state *s)
   bool default_reduction_only = true;
 
   /* Report lookahead tokens (or $default) and reductions.  */
-  if (reds->lookahead_tokens)
+  if (reds->lookaheads)
     for (int i = 0; i < ntokens; i++)
       {
         bool defaulted = false;
@@ -277,7 +277,7 @@ print_reductions (FILE *out, const state *s)
           default_reduction_only = false;
 
         for (int j = 0; j < reds->num; ++j)
-          if (bitset_test (reds->lookahead_tokens[j], i))
+          if (bitset_test (reds->lookaheads[j], i))
             {
               if (! count)
                 {
diff --git a/src/state-item.c b/src/state-item.c
index ed67ad97..d7d1ff8a 100644
--- a/src/state-item.c
+++ b/src/state-item.c
@@ -150,7 +150,7 @@ init_state_items (void)
             ++rule_search_idx;
           if (rule_search_idx < red->num && r == red->rules[rule_search_idx])
             {
-              bitsetv lookahead = red->lookahead_tokens;
+              bitsetv lookahead = red->lookaheads;
               if (lookahead)
                 si->lookahead = lookahead[rule_search_idx];
             }
@@ -163,7 +163,7 @@ init_state_items (void)
           state_item_set (sidx, s, off);
           if (item_number_is_rule_number (ritem[off]))
             {
-              bitsetv lookahead = red->lookahead_tokens;
+              bitsetv lookahead = red->lookaheads;
               if (lookahead)
                 state_items[sidx].lookahead = lookahead[rule_search_idx];
               ++rule_search_idx;
diff --git a/src/state.c b/src/state.c
index bc45460d..4a3d78aa 100644
--- a/src/state.c
+++ b/src/state.c
@@ -101,7 +101,7 @@ reductions_new (int num, rule **reds)
   size_t rules_size = num * sizeof *reds;
   reductions *res = xmalloc (offsetof (reductions, rules) + rules_size);
   res->num = num;
-  res->lookahead_tokens = NULL;
+  res->lookaheads = NULL;
   memcpy (res->rules, reds, rules_size);
   return res;
 }
@@ -260,20 +260,20 @@ state_errs_set (state *s, int num, symbol **tokens)
 `--------------------------------------------------*/
 
 void
-state_rule_lookahead_tokens_print (state const *s, rule const *r, FILE *out)
+state_rule_lookaheads_print (state const *s, rule const *r, FILE *out)
 {
   /* Find the reduction we are handling.  */
   reductions *reds = s->reductions;
   int red = state_reduction_find (s, r);
 
   /* Print them if there are.  */
-  if (reds->lookahead_tokens && red != -1)
+  if (reds->lookaheads && red != -1)
     {
       bitset_iterator biter;
       int k;
       char const *sep = "";
       fprintf (out, "  [");
-      BITSET_FOR_EACH (biter, reds->lookahead_tokens[red], k, 0)
+      BITSET_FOR_EACH (biter, reds->lookaheads[red], k, 0)
         {
           fprintf (out, "%s%s", sep, symbols[k]->tag);
           sep = ", ";
@@ -283,7 +283,7 @@ state_rule_lookahead_tokens_print (state const *s, rule const *r, FILE *out)
 }
 
 void
-state_rule_lookahead_tokens_print_xml (state const *s, rule const *r,
+state_rule_lookaheads_print_xml (state const *s, rule const *r,
                                        FILE *out, int level)
 {
   /* Find the reduction we are handling.  */
@@ -291,12 +291,12 @@ state_rule_lookahead_tokens_print_xml (state const *s, rule const *r,
   int red = state_reduction_find (s, r);
 
   /* Print them if there are.  */
-  if (reds->lookahead_tokens && red != -1)
+  if (reds->lookaheads && red != -1)
     {
       bitset_iterator biter;
       int k;
       xml_puts (out, level, "<lookaheads>");
-      BITSET_FOR_EACH (biter, reds->lookahead_tokens[red], k, 0)
+      BITSET_FOR_EACH (biter, reds->lookaheads[red], k, 0)
         {
           xml_printf (out, level + 1, "<symbol>%s</symbol>",
                       xml_escape (symbols[k]->tag));
diff --git a/src/state.h b/src/state.h
index a274e611..6a2fd1c3 100644
--- a/src/state.h
+++ b/src/state.h
@@ -62,7 +62,7 @@
 
    Each reductions structure describes the possible reductions at the
    state whose number is in the number field.  rules is an array of
-   num rules.  lookahead_tokens is an array of bitsets, one per rule.
+   num rules.  lookaheads is an array of bitsets, one per rule.
 
    Conflict resolution can decide that certain tokens in certain
    states should explicitly be errors (for implementing %nonassoc).
@@ -187,7 +187,7 @@ errs *errs_new (int num, symbol **tokens);
 typedef struct
 {
   int num;
-  bitset *lookahead_tokens;
+  bitset *lookaheads;
   /* Sorted ascendingly on rule number.  */
   rule *rules[1];
 } reductions;
@@ -254,9 +254,9 @@ void state_errs_set (state *s, int num, symbol **errors);
 
 /* Print on OUT all the lookahead tokens such that this STATE wants to
    reduce R.  */
-void state_rule_lookahead_tokens_print (state const *s, rule const *r, FILE *out);
-void state_rule_lookahead_tokens_print_xml (state const *s, rule const *r,
-                                            FILE *out, int level);
+void state_rule_lookaheads_print (state const *s, rule const *r, FILE *out);
+void state_rule_lookaheads_print_xml (state const *s, rule const *r,
+                                      FILE *out, int level);
 
 /* Create/destroy the states hash table.  */
 void state_hash_new (void);
diff --git a/src/tables.c b/src/tables.c
index 883d81e5..052e96e6 100644
--- a/src/tables.c
+++ b/src/tables.c
@@ -200,7 +200,7 @@ conflict_row (state *s)
         /* Find all reductions for token J, and record all that do not
            match ACTROW[J].  */
         for (int i = 0; i < reds->num; i += 1)
-          if (bitset_test (reds->lookahead_tokens[i], j)
+          if (bitset_test (reds->lookaheads[i], j)
               && (actrow[j]
                   != rule_number_as_item_number (reds->rules[i]->number)))
             {
@@ -247,7 +247,7 @@ action_row (state *s)
 
   reductions *reds = s->reductions;
   bool conflicted = false;
-  if (reds->lookahead_tokens)
+  if (reds->lookaheads)
     /* loop over all the rules available here which require
        lookahead (in reverse order to give precedence to the first
        rule) */
@@ -257,7 +257,7 @@ action_row (state *s)
       {
         bitset_iterator biter;
         int j;
-        BITSET_FOR_EACH (biter, reds->lookahead_tokens[i], j, 0)
+        BITSET_FOR_EACH (biter, reds->lookaheads[i], j, 0)
           {
             /* and record this rule as the rule to use if that
                token follows.  */
@@ -308,7 +308,7 @@ action_row (state *s)
     }
 
   /* Turn off default reductions where requested by the user.  See
-     state_lookahead_tokens_count in lalr.c to understand when states are
+     state_lookaheads_count in lalr.c to understand when states are
      labeled as consistent.  */
   {
     char *default_reductions =
diff --git a/tests/torture.at b/tests/torture.at
index 3dbbed5e..f41b8487 100644
--- a/tests/torture.at
+++ b/tests/torture.at
@@ -283,11 +283,11 @@ m4_popdef([AT_TEST])
 ## Many lookahead tokens.   ##
 ## ------------------------ ##
 
-# AT_DATA_LOOKAHEAD_TOKENS_GRAMMAR(FILE-NAME, SIZE)
-# --------------------------------------------------
+# AT_DATA_LOOKAHEADS_GRAMMAR(FILE-NAME, SIZE)
+# -------------------------------------------
 # Create FILE-NAME, containing a self checking parser for a grammar
 # requiring SIZE lookahead tokens.
-m4_define([AT_DATA_LOOKAHEAD_TOKENS_GRAMMAR],
+m4_define([AT_DATA_LOOKAHEADS_GRAMMAR],
 [AT_BISON_OPTION_PUSHDEFS
 AT_DATA([[gengram.pl]],
 [[#! /usr/bin/perl -w
@@ -384,7 +384,7 @@ AT_BISON_OPTION_POPDEFS
 
 AT_SETUP([Many lookahead tokens])
 
-AT_DATA_LOOKAHEAD_TOKENS_GRAMMAR([input.y], [1000])
+AT_DATA_LOOKAHEADS_GRAMMAR([input.y], [1000])
 
 # GNU m4 requires about 70 MiB for this test on a 32-bit host.
 # Ask for 200 MiB, which should be plenty even on a 64-bit host.