Chapitre 2 :   Texte formaté

2.1   Description et but du module

2.2   Fonctionnement

2.2.1   Formatage

let do_put_char c =
  if !cur_out.temp || (Out.is_null !cur_out.out) 
  then do_do_put_char c
  else do_put_char_format c
;;

• Chaque ligne ne doit pas dépasser la taille de la page.
• Il peut y avoir un espace à gauche ou à droite (variables x_start et x_end).
• On peut mettre un retrait pour la première ligne, positif ou négatif (variable first_line).
• Il faut pouvoir l'aligner à gauche, à droite ou au centre (variable align). La justification n'est pas gérée.

---

Figure 2.1 : Format d'un paragraphe

---

type align_t = Left | Center | Right
type flags_t = {
     (...)
    mutable align : align_t;
    mutable in_align : bool;
    mutable hsize : int;
    mutable x : int;
    mutable x_start : int;
    mutable x_end : int;
    mutable last_space : int;
    mutable first_line : int;
    mutable underline : string;
     (...)
  }

let line = String.create (!Parse_opts.width +2);;

let do_put_char_format c =
  if c=' ' then  flags.last_space <- flags.x;
  if flags.x =(-1) then init_line (flags.x_start+flags.first_line)
  line.[flags.x]<-c;

• si le caractère est un retour chariot, on envoie la ligne à l'étape suivante :

   if c='\n' then begin do_put_line (String.sub line 0 (flags.x +1));
      flags.x <- -1;
    end else
      flags.x<-flags.x + 1;
  

• si on dépasse la fin de la ligne, et que le dernier espace rencontré est trop loin, ce qui arrive quand on a un mot plus long que la longueur hsize de la ligne en cours, alors on coupe brutalement le mot à la fin de la ligne et on affiche le reste à la ligne suivante. Le comportement d'H^EV^EA diffère ici de L^AT_EX. Ce dernier coupe en effet les mots en gérant l'hyphénation. Ceci n'a pas été implémenté dans H^EV^EA.

   if flags.x>(flags.x_end +1) then begin
      if (flags.x - flags.last_space) >= flags.hsize then begin
        line.[flags.x-1]<-'\n';
        do_put_line (String.sub line 0 (flags.x));
        init_line flags.x_start;
        line.[flags.x_start]<-c;
        flags.x<-flags.x + 1;
      end
  

• si on dépasse la fin de la ligne, et qu'il y a un espace dans la ligne en cours, on coupe la ligne au niveau de cet espace, puis on envoie la ligne. On réinitialise alors le tampon avec le début du mot qui a été enlevé à la fin de la ligne précédente:

     else begin
        let reste = 
          String.sub line (flags.last_space +1) flags.x - flags.last_space -1
        in
        line.[flags.last_space]<-'\n';
        do_put_line (String.sub line 0 (flags.last_space+1));
        init_line flags.x_start;
        for i = flags.x_start to (flags.x_start+ String.length reste -1) do
          line.[i]<- reste.[i-flags.x_start];
        done;
        flags.x<- flags.x + (String.length reste);
      end;
    end;
  ;;  
  

let init_line n =
  for i = 0 to n-1 do line.[i]<-' ' done;
  flags.x <- n;
  flags.last_space <- n-1
;;

 let ligne = match flags.align with
  | Left -> s
  | Center ->
      let sp = (flags.hsize - (length -flags.x_start))/2 in
      String.concat "" [String.make sp ' '; s]
  | Right ->
      let sp = flags.hsize - length + flags.x_start in
      String.concat "" [ String.make sp ' '; s]
  in
  do_do_put ligne;

2.2.2   Blocs

Les blocs temporaires

sont utilisés essentiellement pour analyser des arguments grâce à l'analyseur principal du module Scan. Le résultat se retrouve dans le module de sortie. Dans le cas du texte, il ne faut pas le formater, et de plus il faut le sauvegarder dans un tampon à part. Cet état est hérité par tous les blocs crées à l'intérieur d'un bloc temporaire.

Les autres blocs

correspondent soit à des changements de style ou à des cas particuliers comme les listes, les tableaux. Leur résultat sera formaté et envoyé dans le fichier de sortie aussitôt.

let open_block bloc arg =
  push out_stack (bloc,arg,!cur_out);
  try_flush_par ();
  if !cur_out.temp || bloc="TEMP" then begin
    cur_out :=
      newstatus
        !cur_out.nostyle
        !cur_out.active
        [] true;
  end;
  try_open_block bloc arg;
;;

 | "QUOTE" ->
      begin
        finit_ligne ();
        push align_stack flags.align;
        push in_align_stack flags.in_align;
        flags.in_align<-true;
        flags.align <- Left;
        flags.first_line<-0;
        flags.x_start<- flags.x_start + 20 * flags.hsize / 100;
        flags.hsize <- flags.x_end - flags.x_start+1;
      end

2.3   Tableaux

2.3.1   Lecture des données

type table_t = {

  };;

val create : 'a -> 'a t
val emit : 'a t -> 'a -> unit
val trim : 'a t -> 'a array

type cell_set = Tabl of cell_t Table.t | Arr of cell_t array
type row_t = {
    mutable haut : int;
    mutable cells : cell_set;}

type align = Top | Middle | Bottom | Base of int
and wrap_t = True | False | Fill
;;
type cell_t = {

  };;

2.3.2   Multicolonnes et Bordures

Multicolonnes

 if !cell.span = 1 then begin
  (...)
 end else begin
   if !table.line=0 then
     for i = 1 to !cell.span do
      Table.emit !table.taille 0
     done;
   multi:=(!table.col,!table.col+ !cell.span-1,!cell.w):: !multi;
 end;

Bordures

2.3.3   Affichage

2.4   Mathématiques

                                /3     5
                                |  xdx=-
                                /2     2

2.4.1   Les displays

2.4.2   Alignements verticaux

Indices et exposants

Fractions

type stack_item =
  Normal of string * string * status
| Freeze of (unit -> unit)
;;

2.4.3   Symboles

\newcommand{\@displayint}{\mbox{/\\|\\/}}
\newcommand{\@displaysum}{\mbox{--\\\char92\\/\\--}}

                                   -- 
                              /    \  
                              |    /  
                              /    --