Texte brut

Un article de Wikipédia, l'encyclopédie libre.
Aller à : navigation, rechercher

Le texte brut traduction de l'anglais plain text est une notion liée à la représentation de texte utilisée entre dispositifs électroniques.

Texte brut Unicode (Unicode plain text)[modifier | modifier le code]

Visualisation de texte brut unicode à traverse l'éditeur de texte Vim, avec l’explorateur de fichiers (à gauche) et l’édition d’un fichier Unicode (à droite)

La notion de fichier texte se rapproche donc des propriétés que le standard Unicode attribue au format nommé plain text en langue anglaise et signifiant texte brut:

  • Le plain text représente le contenu basique et échangeable et inter-opérable du texte
  • Le plain text représente seulement les caractères contenus, sans leur apparence. (Ceci signifie que seule un numérotation des caractère est utilisée, la police d'affichage étant fournie par un mécanisme indépendant)
  • Le plain text peut être affiché de diverses façons et nécessite un processus de rendu pour le rendre visible.
  • Si la séquence de plain text est données à des processus de rendu divers rien ne garanti que le texte aura la même apparence (la taille des caractères, la police, par exemple peuvent varier).
  • Les différents processus de rendu du texte doivent rendre le code lisible dans une intention de lecture (ceci revient à éviter le problème des mojibake)
  • La contrainte de lisibilité contraint les apparences possibles.
  • Le Standard Unicode définit du plain text.
  • La distinction entre du plain text et d'autres formats de données dans le même flux est du ressort de protocoles supérieurs et n'est pas spécifié par Le Standard Unicode lui-même.

Généralités et controverses[modifier | modifier le code]

La notion de texte brut peut se retrouver dans un fichier ou dans un courriel (courrier électronique).

La notion de texte brut (plain text) a comme la notion de texte enrichi (fancy text) été introduite par Unicode [1].

La notion de plain text peut être traduite par texte en clair, pur texte, texte pur, ou texte brut [2].

Linux Information Project en donne une vision plus restrictive dans laquelle seuls les quatre-vingt-seize caractères américains de l'ASCII peuvent faire partie du plain text, la limite à la seule langue anglaise excluant de ce fait les caractères accentués des langues étrangères[3].

En pratique, on peut avoir généralement à préciser, d'une manière ou d'une autre, le répertoire de caractères ou l'encodage associé à un format plain text. En anglais, on peut donc dire plain ASCII text ou plain Unicode text. En français on dira plus facilement texte brut Unicode pour du texte en français ou texte brut ASCII dans des contextes en langue anglaise ou protocolaires. En effet, si l'encodage est inconnu, un texte brut quelconque est inexploitable.

Histoire[modifier | modifier le code]

La notion de texte brut est implicitement assez ancienne puisque vraisemblablement elle remonte sans doute au moins si ce n'est à la notion de machine à écrire, aux premiers langages de programmation utilisant cette technologie.

Dès 1958 et 1961, le fait de concevoir des programmes en Algol n'a vraisemblablement pas pu être réalisé sans avoir recours à la notion de texte brut. Tout comme la langage DEL en 1969 (RFC 5).

Le 30 avril 1975, le RFC 680 fait déjà référence à la notion de plain text, sans pour autant le définir.

Le 21 novembre 1977, un effort de la «Defense Advanced Research Projects Agency of the Department of Defense» aboutit au RFC 733, «STANDARD FOR THE FORMAT OF ARPA NETWORK TEXT MESSAGES», qui définit un standard de protocole pour les messages texte.

Le 13 aout 1982, l'obsolète RFC 822 «STANDARD FOR THE FORMAT OF ARPA INTERNET TEXT MESSAGES» définit un format de texte brut particulier, limité aux seuls caractères de l'ASCII, en en excluant certains des caractères de contrôle, et en introduisant des séquences d'échapement multi-octet (quoted printable).

En Septembre 1993, le RFC 1951 introduit la notion de plain text (texte brut)[4]

La notion de texte brut a été clarifiée par des RFC notamment en 1999.

La notion de texte brut a également été clarifiée par Le Standard Unicode entre 1992 et 2012[Quand ?].

Protocoles[modifier | modifier le code]

L'usage du texte brut peut varier entre protocole et fichier.

Dans un protocole, le protocole spécifie généralement l'encodage utilisé, d'une manière ou d'une autre; la longueur du texte peut ne pas être limité, en fonction du protocole.

Fichier texte[modifier | modifier le code]

Article détaillé : fichier texte.

Un fichier a généralement une taille limitée, alors qu'un protocole peut transférer un flot de données virtuellement infini. Il est généralement admis qu'un système de fichier ne fournit pas d'information sur l'encodage utilisé pour encoder un texte brut donné. Cette information essentielle est alors déterminée à travers un ensemble d'heuristiques. (voir fichier texte).

Texte brut dans un courriel[modifier | modifier le code]

Article détaillé : Courriel et Unicode.

La notion de standardisation du texte brut dans les courriel est abordée par le RFC 2646 «The Text/Plain Format Parameter» de 1999[5] et la Request for Comments: 3676, sous le titre «The Text/Plain Format and DelSp Parameters»[6].

La notion de plain texte est également abordée dans le RFC 2046[7]. Ce RFC précise que la notion de plain text s'accompagne de la définition d'un encodage des caractères.

Toutefois, il se peut que ce RFC ancien ne traite que des problématiques de longueur des lignes, sans définir exactement ce qu'est le texte brut.

évolutions et perspectives[modifier | modifier le code]

Balisage[modifier | modifier le code]

Le RFC 2482 «Language Tagging in Unicode Plain Text» discute des perspectives de balisages du texte brut Unicode[8].

Texte brut approché en mathématiques[modifier | modifier le code]

La note technique 28 de l'Unicode traite de la problématique de la représentation des symboles mathématiques sous forme de texte brut approché et aborde des notions techniques dépassant les limites de la définition du texte brut[9].

Alors que les mathématiques sont un langage international, en tout ou partie, leur représentation informatique a pu être négligée lors de la création de différents systèmes de codage des caractères. Toutefois, ces symboles ont bénéficié d'une forte prise en charge par l'Unicode [10], éventuellement à partir de la version 3 et de l'an 2000[11].

Les mathématiques posent la question de l'expression non linéaire, c'est-à-dire des expressions pouvant nécessiter un format particulier dans l'espace de la page, comme les fractions ou les matrices. Des systèmes de codages comme ISO-8859-1 et Windows 1252 se limitaient à des caractères limités relatifs aux quarts et à leur multiples (¼,½,¾). Ceci a conduit les scientifiques à utiliser des outils tels que LaTeX ou MathML.

Unicode permet d'exprimer de nombreuses expressions mathématiques avec du texte pratiquement brut et lisible. D'un point de vue technique ce format serait légèrement formaté par des balises, éventuellement. Ce format est un format linéaire mais peut aussi être affiché sous forme formatée éventuellement. Dans la note «Unicode Nearly Plain-Text Encoding of Mathematics» Version 3 [12], ces deux variantes sont nommées linear format format linéaire, pour un affichage sous forme de texte brut, et built-up presentation format pour un affichage bénéficiant d'un affichage complexe.

Exemple de programmation de formules mathématiques en C++

C++ en texte brut ASCII :

    1       void IHBMWM(void)
    2    {
    3           gammap = gamma*sqrt(1 + I2);
    4           upsilon = cmplx(gamma+gamma1, Delta);
    5           alphainc = alpha0*(1-(gamma*gamma*I2/gammap)/(gammap + upsilon));
    6           if (!gamma1 && fabs(Delta*T1) < 0.01)
    7                   alphacoh = -half*alpha0*I2*pow(gamma/gammap, 3);
    8           else
    9           {
   10                   Gamma = 1/T1 + gamma1;
   11                   I2sF = (I2/T1)/cmplx(Gamma, Delta);
   12                   betap2 = upsilon*(upsilon + gamma*I2sF);
   13                   beta = sqrt(betap2);
   14                   alphacoh = 0.5*gamma*alpha0*(I2sF*(gamma + upsilon)
   15                                  /(gammap*gammap – betap2))
   16                                  *((1+gamma/beta)*(beta – upsilon)/(beta + upsilon)
   17                                  - (1+gamma/gammap)*(gammap – upsilon)/
   18                                  (gammap + upsilon));
   19           }
   20           alpha1 = alphainc + alphacoh;
   21    } 

++ en texte brut Unicode :

    1       void IHBMWM(void)
    2    {
    3            γ = γ • √(1 + I2 );
    4            υ = γ + γ1 + i • Δ;
    5            α_inc = α0 • (1 − (γ • γ • I2 /γ’)/(γ’ + υ));
    6           if (! γ1 || fabs(Δ • T1 ) < 0.01)
    7                       α_coh = −.5 • α0 • I2 • pow(γ/γ’, 3);
    8           else
    9           {
   10                       Γ = 1/T1 + γ1;
   11                      I2 F = (I2 /T1 )/(Γ + i • Δ);
   12                       β 2 = υ • (υ + γ • I2 F);
   13                       β = √β 2;
   14                       α_coh = .5 • γ • α0 • (I2 F(γ + υ)/(γ’ • γ’ − β 2 ))
   15                                 ((1 + γ/β) • (β − υ)/(β + υ) − (1 + γ/γ’) • (γ’ − υ)/(γ’ + υ));
   16           }
   17            α1 = α_inc + α_coh;
   18    }

La version en format linéaire afficherait les indes 1 et coh sous forme d'indice, àalors qu'une version purement formatée afficherait également les fractions sous forme de fraction.

Notes et références[modifier | modifier le code]

Voir aussi[modifier | modifier le code]

Fichier texte

Liens internes[modifier | modifier le code]