src/Pure/Syntax/parser.ML

      and also as an entry in "lambdas"*)
 
 
 (*productions for which no starting token is
   known yet are associated with this token*)
-val UnknownStart = Lexicon.eof;
+val unknown_start = Lexicon.eof;
 
 (*get all NTs that are connected with a list of NTs*)
 fun connected_with _ ([]: nt_tag list) relatives = relatives
   | connected_with chains (root :: roots) relatives =
       let val branches = subtract (op =) relatives (these (AList.lookup (op =) chains root));

 
                             (*existing productions whose lookahead may depend on l*)
                             val tk_prods =
                               these
                                 (AList.lookup (op =) nt_prods
-                                  (SOME (hd l_starts handle Empty => UnknownStart)));
+                                  (SOME (hd l_starts handle Empty => unknown_start)));
 
                             (*add_lambda is true if an existing production of the nt
                               produces lambda due to the new lambda NT l*)
                             val (add_lambda, nt_dependencies, added_tks, nt_prods') =
                               examine_prods tk_prods false [] [] nt_prods;

                   (if is_some start_tk then [the start_tk] else [],
                     map starts_for_nt start_nts);
 
               val opt_starts =
                (if new_lambda then [NONE]
-                else if null start_tks then [SOME UnknownStart]
+                else if null start_tks then [SOME unknown_start]
                 else []) @ map SOME start_tks;
 
               (*add lhs NT to list of dependent NTs in lookahead*)
               fun add_nts [] = ()
                 | add_nts (nt :: nts) =

                   let
                     (*token under which old productions which
                       depend on changed_nt could be stored*)
                     val key =
                       (case find_first (not o member (op =) new_tks) (starts_for_nt changed_nt) of
-                        NONE => SOME UnknownStart
+                        NONE => SOME unknown_start
                       | t => t);
 
                     (*copy productions whose lookahead depends on changed_nt;
-                      if key = SOME UnknownToken then tk_prods is used to hold
+                      if key = SOME unknown_start then tk_prods is used to hold
                       the productions not copied*)
                     fun update_prods [] result = result
                       | update_prods ((p as (rhs, _: string, _: nt_tag)) :: ps)
                             (tk_prods, nt_prods) =
                           let

                                    |> AList.update (op =) (SOME tk, tk_prods')
                                    |> copy tks
                                  end;
                             val result =
                               if update then (tk_prods, copy new_tks nt_prods)
-                              else if key = SOME UnknownStart then (p :: tk_prods, nt_prods)
+                              else if key = SOME unknown_start then (p :: tk_prods, nt_prods)
                               else (tk_prods, nt_prods);
                           in update_prods ps result end;
 
                     (*copy existing productions for new starting tokens*)
                     fun process_nts [] added = added

                             (*associate productions with new lookahead tokens*)
                             val (tk_prods', nt_prods') = update_prods tk_prods ([], nt_prods);
 
                             val nt_prods' =
                               nt_prods'
-                              |> (key = SOME UnknownStart) ? AList.update (op =) (key, tk_prods');
+                              |> (key = SOME unknown_start) ? AList.update (op =) (key, tk_prods');
 
                             val added_tks = subtract Lexicon.matching_tokens old_tks new_tks;
                           in
                             if null added_tks then
                               (Array.update (prods, nt, (lookahead, nt_prods'));

   symb list *       (*rest of rhs*)
   string *          (*name of production*)
   int;              (*index for previous state list*)
 
 
-(*Get all rhss with precedence >= minPrec*)
-fun getRHS minPrec = filter (fn (_, _, prec:int) => prec >= minPrec);
-
-(*Get all rhss with precedence >= minPrec and < maxPrec*)
-fun getRHS' minPrec maxPrec =
-  filter (fn (_, _, prec:int) => prec >= minPrec andalso prec < maxPrec);
+(*Get all rhss with precedence >= min_prec*)
+fun get_RHS min_prec = filter (fn (_, _, prec:int) => prec >= min_prec);
+
+(*Get all rhss with precedence >= min_prec and < max_prec*)
+fun get_RHS' min_prec max_prec =
+  filter (fn (_, _, prec:int) => prec >= min_prec andalso prec < max_prec);
 
 (*Make states using a list of rhss*)
-fun mkStates i minPrec lhsID rhss =
-  let fun mkState (rhs, id, prodPrec) = (lhsID, prodPrec, [], rhs, id, i);
-  in map mkState rhss end;
+fun mk_states i min_prec lhs_ID rhss =
+  let fun mk_state (rhs, id, prod_prec) = (lhs_ID, prod_prec, [], rhs, id, i);
+  in map mk_state rhss end;
 
 (*Add parse tree to list and eliminate duplicates
   saving the maximum precedence*)
 fun conc (t: parsetree list, prec:int) [] = (NONE, [(t, prec)])
   | conc (t, prec) ((t', prec') :: ts) =

       if A = B
       then used' @ ((A, (prec, ts)) :: used)
       else update (used, hd :: used')
   in update (used, []) end;
 
-fun getS A maxPrec Si =
+fun getS A max_prec Si =
   filter
-    (fn (_, _, _, Nonterminal (B, prec) :: _, _, _) => A = B andalso prec <= maxPrec
+    (fn (_, _, _, Nonterminal (B, prec) :: _, _, _) => A = B andalso prec <= max_prec
       | _ => false) Si;
 
-fun getS' A maxPrec minPrec Si =
+fun getS' A max_prec min_prec Si =
   filter
     (fn (_, _, _, Nonterminal (B, prec) :: _, _, _)
-          => A = B andalso prec > minPrec andalso prec <= maxPrec
+          => A = B andalso prec > min_prec andalso prec <= max_prec
       | _ => false) Si;
 
-fun getStates Estate i ii A maxPrec =
+fun get_states Estate i ii A max_prec =
   filter
-    (fn (_, _, _, Nonterminal (B, prec) :: _, _, _) => A = B andalso prec <= maxPrec
+    (fn (_, _, _, Nonterminal (B, prec) :: _, _, _) => A = B andalso prec <= max_prec
       | _ => false)
     (Array.sub (Estate, ii));
 
 
 fun movedot_term (A, j, ts, Terminal a :: sa, id, i) c =

     fun all_prods_for nt = prods_for prods chains true c [nt];
 
     fun processS used [] (Si, Sii) = (Si, Sii)
       | processS used (S :: States) (Si, Sii) =
           (case S of
-            (_, _, _, Nonterminal (nt, minPrec) :: _, _, _) =>
+            (_, _, _, Nonterminal (nt, min_prec) :: _, _, _) =>
               let (*predictor operation*)
                 val (used', new_states) =
                   (case AList.lookup (op =) used nt of
-                    SOME (usedPrec, l) => (*nonterminal has been processed*)
-                      if usedPrec <= minPrec then
+                    SOME (used_prec, l) => (*nonterminal has been processed*)
+                      if used_prec <= min_prec then
                         (*wanted precedence has been processed*)
                         (used, movedot_lambda S l)
                       else (*wanted precedence hasn't been parsed yet*)
                         let
                           val tk_prods = all_prods_for nt;
 
-                          val States' = mkStates i minPrec nt
-                                          (getRHS' minPrec usedPrec tk_prods);
-                        in (update_prec (nt, minPrec) used,
+                          val States' = mk_states i min_prec nt
+                                          (get_RHS' min_prec used_prec tk_prods);
+                        in (update_prec (nt, min_prec) used,
                             movedot_lambda S l @ States')
                         end
 
                   | NONE => (*nonterminal is parsed for the first time*)
                       let
                         val tk_prods = all_prods_for nt;
-                        val States' = mkStates i minPrec nt (getRHS minPrec tk_prods);
-                      in ((nt, (minPrec, [])) :: used, States') end);
+                        val States' = mk_states i min_prec nt (get_RHS min_prec tk_prods);
+                      in ((nt, (min_prec, [])) :: used, States') end);
 
                 val dummy =
                   if not (! warned) andalso
                      length (new_states @ States) > ! branching_level then
                     (warning "Currently parsed expression could be extremely ambiguous.";

                             val Slist = getS' A prec n Si;
                             val States' = map (movedot_nonterm tt) Slist;
                           in processS used' (States' @ States) (S :: Si, Sii) end)
                   end
                 else
-                  let val Slist = getStates Estate i j A prec
+                  let val Slist = get_states Estate i j A prec
                   in processS used (map (movedot_nonterm tt) Slist @ States) (S :: Si, Sii) end
               end)
   in processS [] states ([], []) end;