New functions in [GrammarFunctor].

- [Terminal.init], [Nonterminal.init], [Production.init] create arrays
  indexed with (integer codes for) symbols and productions.
- Several functions allow finding the attributes attached with
  symbols, with producers, and with the grammar.

src/grammarFunctor.ml

@@ -118,6 +118,9 @@ module Nonterminal = struct
   let positions nt =
     (StringMap.find (print false nt) grammar.rules).positions
 
+  let init f =
+    Array.init n f
+
   let iter f =
     Misc.iteri n f
 
@@ -153,6 +156,18 @@ module Nonterminal = struct
   let tabulate f =
     Array.get (Array.init n f)
 
+  let attributes : Syntax.attributes array =
+    Array.make n []
+
+  let () =
+    StringMap.iter (fun nonterminal { attributes = attrs } ->
+      let nt = lookup nonterminal in
+      attributes.(nt) <- attrs
+    ) grammar.rules
+
+  let attributes nt =
+    attributes.(nt)
+
 end
 
 (* Sets and maps over nonterminals. *)
@@ -250,6 +265,9 @@ module Terminal = struct
   let ocamltype tok =
     token_properties.(tok).tk_ocamltype
 
+  let init f =
+    Array.init n f
+
   let iter f =
     Misc.iteri n f
 
@@ -280,6 +298,9 @@ module Terminal = struct
     with Not_found ->
       None
 
+  let attributes tok =
+    token_properties.(tok).tk_attributes
+
   (* The sub-module [Word] offers an implementation of words (that is,
      sequences) of terminal symbols. It is used by [LRijkstra]. We
      make it a functor, because it has internal state (a hash table)
@@ -563,6 +584,9 @@ module Production = struct
   let positions : Positions.t list array =
     Array.make n []
 
+  let rhs_attributes : Syntax.attributes array array =
+    Array.make n [||]
+
   let (start : int),
       (startprods : index NonterminalMap.t) =
     StringSet.fold (fun nonterminal (k, startprods) ->
@@ -586,13 +610,14 @@ module Production = struct
     let dummy = ProductionLevel (InputFile.builtin_input_file, 0) in
     Array.make n dummy
 
-  let (_ : int) = StringMap.fold (fun nonterminal { branches = branches } k ->
+  let (_ : int) = StringMap.fold (fun nonterminal { branches } k ->
     let nt = Nonterminal.lookup nonterminal in
     let k' = List.fold_left (fun k branch ->
       let symbols = Array.of_list branch.producers in
       table.(k) <- (nt, Array.map (fun producer -> Symbol.lookup (producer_symbol producer)) symbols);
       identifiers.(k) <- Array.map producer_identifier symbols;
       actions.(k) <- Some branch.action;
+      rhs_attributes.(k) <- Array.map producer_attributes symbols;
       production_level.(k) <- branch.branch_production_level;
       prec_decl.(k) <- branch.branch_prec_annotation;
       positions.(k) <- [ branch.branch_position ];
@@ -602,8 +627,7 @@ module Production = struct
     k'
   ) grammar.rules start
 
-  (* Iteration over the productions associated with a specific
-     nonterminal. *)
+  (* Iteration over the productions associated with a specific nonterminal. *)
 
   let iternt nt f =
     let k, k' = ntprods.(nt) in
@@ -677,6 +701,12 @@ module Production = struct
   let positions prod =
     positions.(prod)
 
+  let lhs_attributes prod =
+    Nonterminal.attributes (nt prod)
+
+  let rhs_attributes prod =
+    rhs_attributes.(prod)
+
   let startsymbol2startprod nt =
     try
       NonterminalMap.find nt startprods
@@ -685,6 +715,9 @@ module Production = struct
 
   (* Iteration. *)
 
+  let init f =
+    Array.init n f
+
   let iter f =
     Misc.iteri n f
 
@@ -1349,6 +1382,9 @@ module Analysis = struct
 
   let follow = follow
 
+  let attributes =
+    grammar.gr_attributes
+
 end
 
 (* ------------------------------------------------------------------------ *)

src/grammarFunctor.mli

@@ -70,6 +70,10 @@ module Nonterminal : sig
 
   val ocamltype_of_start_symbol: t -> Stretch.ocamltype
 
+  (* Creation of a table indexed by nonterminals. *)
+
+  val init: (t -> 'a) -> 'a array
+
   (* Iteration over nonterminals. The order in which elements are
      examined, and the order of [map]'s output list, correspond to the
      numeric indices produced by [n2i] above. *)
@@ -98,6 +102,11 @@ module Nonterminal : sig
 
   val is_start: t -> bool
 
+  (* [attributes nt] is the list of attributes attached with the nonterminal
+     symbol [nt]. *)
+
+  val attributes: t -> Syntax.attribute list
+
 end
 
 (* ------------------------------------------------------------------------ *)
@@ -167,6 +176,10 @@ module Terminal : sig
   val pseudo: t -> bool
   val real: t -> bool
 
+  (* Creation of a table indexed by terminals. *)
+
+  val init: (t -> 'a) -> 'a array
+
   (* Iteration over terminals. The order in which elements are
      examined, and the order of [map]'s output list, correspond to the
      numeric indices produced by [t2i] above. *)
@@ -183,6 +196,11 @@ module Terminal : sig
 
   val iter_real: (t -> unit) -> unit
 
+  (* [attributes t] is the list of attributes attached with the terminal
+     symbol [t]. *)
+
+  val attributes: t -> Syntax.attribute list
+
   (* The sub-module [Word] offers an implementation of words (that is,
      sequences) of terminal symbols. It is used by [LRijkstra]. We
      make it a functor, because it has internal state (a hash table)
@@ -352,6 +370,19 @@ module Production : sig
 
   val positions: index -> Positions.t list
 
+  (* [lhs_attributes prod] returns the attributes attached with the
+     head symbol of the production [prod]. It is equivalent to
+     [Nonterminal.attributes (nt prod)]. [rhs_attributes prod] returns
+     an array of the attributes attached with each element in the
+     right-hand side of the production [prod]. *)
+
+  val lhs_attributes: index -> Syntax.attributes
+  val rhs_attributes: index -> Syntax.attributes array
+
+  (* Creation of a table indexed by productions. *)
+
+  val init: (index -> 'a) -> 'a array
+
   (* Iteration over all productions. The order in which elements
      are examined, and the order of [map]'s output list, correspond
      to the numeric indices produced by [p2i] above. *)
@@ -466,6 +497,10 @@ module Analysis : sig
 
   val follow: Nonterminal.t -> TerminalSet.t
 
+  (* [attributes] are the attributes attached with the grammar. *)
+
+  val attributes: Syntax.attributes
+
 end
 
 (* ------------------------------------------------------------------------ *)