For consistency, use `lookahead' instead of `look-ahead' or

`look_ahead'.  Discussed starting at
<http://lists.gnu.org/archive/html/bison-patches/2006-01/msg00049.html>
and then at
<http://lists.gnu.org/archive/html/bison-patches/2006-06/msg00017.html>.
* NEWS: For the next release, note the change to `--report'.
* TODO, doc/bison.1: Update English.
* doc/bison.texinfo: Update English.
(Understanding Your Parser, Bison Options): Document as
`--report=lookahead' rather than `--report=look-ahead'.
* src/conflicts.c: Update English in comments.
(lookahead_set): Rename from look_ahead_set.
(flush_reduce): Rename argument look_ahead_tokens to lookahead_tokens.
(resolve_sr_conflict): Rename local look_ahead_tokens to
lookahead_tokens, and update other uses.
(flush_shift, set_conflicts, conflicts_solve, count_sr_conflicts,
count_rr_conflicts, conflicts_free): Update uses.
* src/getargs.c (report_args): Move "lookahead" before alternate
spellings.
(report_types): Update uses.
(usage): For `--report' usage description, state `lookahead' spelling
rather than `look-ahead'.
* src/getargs.h (report.report_lookahead_tokens): Rename from
report_look_ahead_tokens.
* src/lalr.c: Update English in comments.
(compute_lookahead_tokens): Rename from compute_look_ahead_tokens.
(state_lookahead_tokens_count): Rename from
state_look_ahead_tokens_count.
Rename local n_look_ahead_tokens to n_lookahead_tokens.
(lookahead_tokens_print): Rename from look_ahead_tokens_print.
Rename local n_look_ahead_tokens to n_lookahead_tokens.
Update other uses.
Update English in output.
(add_lookback_edge, initialize_LA, lalr, lalr_free): Update uses.
* src/print.c: Update English in comments.
(lookahead_set): Rename from look_ahead_set.
(print_reduction): Rename argument lookahead_token from
look_ahead_token.
(print_core, state_default_rule, print_reductions, print_results):
Update uses.
* src/print_graph.c: Update English in comments.
(print_core): Update uses.
* src/state.c: Update English in comments.
(reductions_new): Update uses.
(state_rule_lookahead_tokens_print): Rename from
state_rule_look_ahead_tokens_print, and update other uses.
* src/state.h: Update English in comments.
(reductions.lookahead_tokens): Rename from look_ahead_tokens.
(state_rule_lookahead_tokens_print): Rename from
state_rule_look_ahead_tokens_print.
* src/tables.c: Update English in comments.
(conflict_row, action_row): Update uses.
* tests/glr-regression.at
(Incorrect lookahead during deterministic GLR,
Incorrect lookahead during nondeterministic GLR): Rename
print_look_ahead to print_lookahead.
* tests/torture.at: Update English in comments.
(AT_DATA_LOOKAHEAD_TOKENS_GRAMMAR): Rename from
AT_DATA_LOOK_AHEAD_TOKENS_GRAMMAR.
(Many lookahead tokens): Update uses.
* data/glr.c: Update English in comments.
* lalr1.cc: Likewise.
* yacc.c: Likewise.
* src/conflicts.h: Likewise.
* src/lalr.h: Likewise.
* src/main.c: Likewise.
* src/output.c: Likewise.
* src/parse-gram.c: Likewise.
* src/tables.h: Likewise.
* tests/calc.at: Likewise.

1 files changed, 40 insertions, 40 deletions

diff --git a/src/lalr.c b/src/lalr.c
index 65c55ab7..e7f51455 100644
--- a/src/lalr.c
+++ b/src/lalr.c
@@ -1,4 +1,4 @@
-/* Compute look-ahead criteria for Bison.
+/* Compute lookahead criteria for Bison.
 
    Copyright (C) 1984, 1986, 1989, 2000, 2001, 2002, 2003, 2004, 2005,
    2006 Free Software Foundation, Inc.
@@ -22,7 +22,7 @@
 
 
 /* Compute how to make the finite state machine deterministic; find
-   which rules need look-ahead in each state, and which look-ahead
+   which rules need lookahead in each state, and which lookahead
    tokens they accept.  */
 
 #include <config.h>
@@ -219,9 +219,9 @@ add_lookback_edge (state *s, rule *r, goto_number gotono)
 {
   int ri = state_reduction_find (s, r);
   goto_list *sp = xmalloc (sizeof *sp);
-  sp->next = lookback[(s->reductions->look_ahead_tokens - LA) + ri];
+  sp->next = lookback[(s->reductions->lookahead_tokens - LA) + ri];
   sp->value = gotono;
-  lookback[(s->reductions->look_ahead_tokens - LA) + ri] = sp;
+  lookback[(s->reductions->lookahead_tokens - LA) + ri] = sp;
 }
 
 
@@ -314,7 +314,7 @@ compute_FOLLOWS (void)
 
 
 static void
-compute_look_ahead_tokens (void)
+compute_lookahead_tokens (void)
 {
   size_t i;
   goto_list *sp;
@@ -332,27 +332,27 @@ compute_look_ahead_tokens (void)
 }
 
 
-/*-----------------------------------------------------.
-| Count the number of look-ahead tokens required for S |
-| (N_LOOK_AHEAD_TOKENS member).                        |
-`-----------------------------------------------------*/
+/*----------------------------------------------------.
+| Count the number of lookahead tokens required for S |
+| (N_LOOKAHEAD_TOKENS member).                        |
+`----------------------------------------------------*/
 
 static int
-state_look_ahead_tokens_count (state *s)
+state_lookahead_tokens_count (state *s)
 {
   int k;
-  int n_look_ahead_tokens = 0;
+  int n_lookahead_tokens = 0;
   reductions *rp = s->reductions;
   transitions *sp = s->transitions;
 
-  /* We need a look-ahead either to distinguish different
+  /* We need a lookahead either to distinguish different
      reductions (i.e., there are two or more), or to distinguish a
      reduction from a shift.  Otherwise, it is straightforward,
      and the state is `consistent'.  */
   if (rp->num > 1
       || (rp->num == 1 && sp->num &&
 	  !TRANSITION_IS_DISABLED (sp, 0) && TRANSITION_IS_SHIFT (sp, 0)))
-    n_look_ahead_tokens += rp->num;
+    n_lookahead_tokens += rp->num;
   else
     s->consistent = 1;
 
@@ -363,13 +363,13 @@ state_look_ahead_tokens_count (state *s)
 	break;
       }
 
-  return n_look_ahead_tokens;
+  return n_lookahead_tokens;
 }
 
 
-/*-----------------------------------------------------.
-| Compute LA, NLA, and the look_ahead_tokens members.  |
-`-----------------------------------------------------*/
+/*----------------------------------------------------.
+| Compute LA, NLA, and the lookahead_tokens members.  |
+`----------------------------------------------------*/
 
 static void
 initialize_LA (void)
@@ -377,10 +377,10 @@ initialize_LA (void)
   state_number i;
   bitsetv pLA;
 
-  /* Compute the total number of reductions requiring a look-ahead.  */
+  /* Compute the total number of reductions requiring a lookahead.  */
   nLA = 0;
   for (i = 0; i < nstates; i++)
-    nLA += state_look_ahead_tokens_count (states[i]);
+    nLA += state_lookahead_tokens_count (states[i]);
   /* Avoid having to special case 0.  */
   if (!nLA)
     nLA = 1;
@@ -388,54 +388,54 @@ initialize_LA (void)
   pLA = LA = bitsetv_create (nLA, ntokens, BITSET_FIXED);
   lookback = xcalloc (nLA, sizeof *lookback);
 
-  /* Initialize the members LOOK_AHEAD_TOKENS for each state whose reductions
-     require look-ahead tokens.  */
+  /* Initialize the members LOOKAHEAD_TOKENS for each state whose reductions
+     require lookahead tokens.  */
   for (i = 0; i < nstates; i++)
     {
-      int count = state_look_ahead_tokens_count (states[i]);
+      int count = state_lookahead_tokens_count (states[i]);
       if (count)
 	{
-	  states[i]->reductions->look_ahead_tokens = pLA;
+	  states[i]->reductions->lookahead_tokens = pLA;
 	  pLA += count;
 	}
     }
 }
 
 
-/*----------------------------------------------.
-| Output the look-ahead tokens for each state.  |
-`----------------------------------------------*/
+/*---------------------------------------------.
+| Output the lookahead tokens for each state.  |
+`---------------------------------------------*/
 
 static void
-look_ahead_tokens_print (FILE *out)
+lookahead_tokens_print (FILE *out)
 {
   state_number i;
   int j, k;
-  fprintf (out, "Look-ahead tokens: BEGIN\n");
+  fprintf (out, "Lookahead tokens: BEGIN\n");
   for (i = 0; i < nstates; ++i)
     {
       reductions *reds = states[i]->reductions;
       bitset_iterator iter;
-      int n_look_ahead_tokens = 0;
+      int n_lookahead_tokens = 0;
 
-      if (reds->look_ahead_tokens)
+      if (reds->lookahead_tokens)
 	for (k = 0; k < reds->num; ++k)
-	  if (reds->look_ahead_tokens[k])
-	    ++n_look_ahead_tokens;
+	  if (reds->lookahead_tokens[k])
+	    ++n_lookahead_tokens;
 
-      fprintf (out, "State %d: %d look-ahead tokens\n",
-	       i, n_look_ahead_tokens);
+      fprintf (out, "State %d: %d lookahead tokens\n",
+	       i, n_lookahead_tokens);
 
-      if (reds->look_ahead_tokens)
+      if (reds->lookahead_tokens)
 	for (j = 0; j < reds->num; ++j)
-	  BITSET_FOR_EACH (iter, reds->look_ahead_tokens[j], k, 0)
+	  BITSET_FOR_EACH (iter, reds->lookahead_tokens[j], k, 0)
 	  {
 	    fprintf (out, "   on %d (%s) -> rule %d\n",
 		     k, symbols[k]->tag,
 		     reds->rules[j]->number);
 	  };
     }
-  fprintf (out, "Look-ahead tokens: END\n");
+  fprintf (out, "Lookahead tokens: END\n");
 }
 
 void
@@ -446,10 +446,10 @@ lalr (void)
   initialize_F ();
   build_relations ();
   compute_FOLLOWS ();
-  compute_look_ahead_tokens ();
+  compute_lookahead_tokens ();
 
   if (trace_flag & trace_sets)
-    look_ahead_tokens_print (stderr);
+    lookahead_tokens_print (stderr);
 }
 
 
@@ -458,6 +458,6 @@ lalr_free (void)
 {
   state_number s;
   for (s = 0; s < nstates; ++s)
-    states[s]->reductions->look_ahead_tokens = NULL;
+    states[s]->reductions->lookahead_tokens = NULL;
   bitsetv_free (LA);
 }