commit e6261f4b2fbc7cf0d568173c93583c3181d3780c parent ec0cbc13d698fd4cf1d6e4a2cbf5e1f6efef4acf Auteur: Selve <selve@asteride.xyz> Date: Thu, 25 Jan 2024 19:05:03 -0500 [cont] publication d'un nouvel article Diffstat:
30 files changed, 720 insertions(+), 98 deletions(-)
diff --git a/.gitignore b/.gitignore @@ -1,6 +1,6 @@ brouillons dst -*.aplat +*.plat liens/gemini liens/http liens/https diff --git a/construire.sh b/construire.sh @@ -1,31 +1,29 @@ #!/bin/sh -set -e - DOS_LIB="lib" DOS_SRC="src" DOS_DST="dst" DOS_LIENS="liens" RACINE="asteride.xyz/~selve" -FCH_LIENS_STD="$DOS_LIENS/liens.dbt" +FCH_LIENS_STD="$DOS_LIENS/liens.aplat" # $1 protocole # $2 extension liens_std() { echo "$FCH_LIENS_STD -> $DOS_LIENS/$1" - aplat <"$FCH_LIENS_STD" | exclure -vproto="$1" | \ + aplat <"$FCH_LIENS_STD" | bloquer -vproto="$1" | \ awk -v plan="$1" -v ext="$2" -f "$DOS_LIB/general.awk" \ -f "$DOS_LIB/liens/gen.awk" \ >"$DOS_LIENS/$1" } humans() { - special="humans.special.dbt" - inter="${special%.dbt}.aplat" - dst="${special%.special.dbt}.txt" - tous="$(find "$DOS_SRC/" -type f -name "*.$1.aplat" \ - ! -name 'humans.special.aplat')" + special="humans.special.aplat" + inter="${special%.aplat}.plat" + dst="${special%.special.aplat}.txt" + tous="$(find "$DOS_SRC/" -type f -name "*.$1.plat" \ + ! -name 'humans.special.plat')" echo "$DOS_SRC/$special -> $DOS_DST/$1/$dst" aplat <"$DOS_SRC/$special" >"$DOS_SRC/$inter" awk -f "$DOS_LIB/general.awk" -f "$DOS_LIB/humans.awk" \ @@ -35,10 +33,10 @@ humans() { # $1 protocole # $2 destination robots.txt() { - special="$DOS_SRC/robots.special.dbt" + special="$DOS_SRC/robots.special.aplat" dst="$DOS_DST/$1/robots.txt" echo "$special -> $dst" - aplat <"$special" | exclure -vdest="$2" | \ + aplat <"$special" | bloquer -vdest="$2" | \ awk -v fichier="$DOS_LIENS/$1" \ -f "$DOS_LIB/general.awk" \ -f "$DOS_LIB/liens/rempl.awk" | \ @@ -86,7 +84,7 @@ flux() { flux="$4" shift 4 echo "$f -> $flux" - aplat <"$f" | exclure -vdest="$dest" | awk -v fichier="$DOS_LIENS/$proto" \ + aplat <"$f" | bloquer -vdest="$dest" | awk -v fichier="$DOS_LIENS/$proto" \ -f "$DOS_LIB/general.awk" -f "$DOS_LIB/liens/rempl.awk" | awk -f "$DOS_LIB/general.awk" -f "$DOS_LIB/atom.awk" - "$@" \ >"$flux" @@ -95,20 +93,20 @@ flux() { # $1 protocole # $2 destination flux_cybercarnet() { - fichiers="$(find "$DOS_SRC/articles" -type f -name "*.$1.aplat")" - flux "$DOS_SRC/flux/cybercarnet.special.dbt" "$1" "$2" \ + fichiers="$(find "$DOS_SRC/articles" -type f -name "*.$1.plat")" + flux "$DOS_SRC/flux/cybercarnet.special.aplat" "$1" "$2" \ "$DOS_DST/$2/flux/cybercarnet_$1.atom" $fichiers } # $1 protocole # $2 destination gen_aplat() { - for f in $(find "$DOS_SRC" -type f -name '*.dbt' \ - ! -name '*.special.dbt') + for f in $(find "$DOS_SRC" -type f -name '*.aplat' \ + ! -name '*.special.aplat') do - res="${f%.dbt}.$1.aplat" + res="${f%.aplat}.$1.plat" echo "$f -> $res" - aplat <"$f" | exclure -vdest="$2" | \ + aplat <"$f" | bloquer -vdest="$2" | \ awk -v fichier="$DOS_LIENS/$1" \ -f "$DOS_LIB/general.awk" \ -f "$DOS_LIB/liens/rempl.awk" >"$res" @@ -119,9 +117,9 @@ gen_aplat() { # $2 format # $3 extension gen_final() { - for f in $(find "$DOS_SRC" -type f -name "*.$1.aplat" ) + for f in $(find "$DOS_SRC" -type f -name "*.$1.plat" ) do - res="${f%.$1.aplat}.$3" + res="${f%.$1.plat}.$3" res="$DOS_DST/$1/${res#$DOS_SRC/}" echo "$f -> $res" awk -f "$DOS_LIB/general.awk" \ @@ -185,7 +183,7 @@ compresser() { nettoyer() { rm -f "$DOS_LIENS/gemini" "$DOS_LIENS/http" "$DOS_LIENS/https" - find "$DOS_SRC" -type f ! \( -name '*.dbt' -o -name '*.cp' \) | \ + find "$DOS_SRC" -type f ! \( -name '*.aplat' -o -name '*.cp' \) | \ xargs rm -f rm -rf "$DOS_DST" } diff --git a/doc/éléments.txt b/doc/éléments.txt @@ -58,6 +58,14 @@ Voir aussi :@:ref:std: Contient un identifiant qu'un programme externe remplacera par une URL. Utile pour éviter l'élément :si:. +:it: + +Italique + +:code: + +Bout de code. + :liste: Décrit une liste. diff --git a/lib/general.awk b/lib/general.awk @@ -66,14 +66,17 @@ function metadonnees_supp(META, DOMAINE, etq) { } function dechapper_cont(TEXTE) { - gsub(/\\[ntr]/, " ", TEXTE) + gsub(/\\[nt]/, " ", TEXTE) + gsub(/\\\\/, "\\", TEXTE) return TEXTE } function dechapper_pre(TEXTE) { gsub(/\\n/, "\n", TEXTE) gsub(/\\t/, "\t", TEXTE) - gsub(/\\r/, "\r", TEXTE) + gsub(/\\\\/, "\\", TEXTE) + gsub(/\\\n/, "\\n", TEXTE) + gsub(/\\\t/, "\\t", TEXTE) return TEXTE } diff --git a/lib/pres/fonctions.awk b/lib/pres/fonctions.awk @@ -21,6 +21,18 @@ function lien_ouv(META, ETQ) { function lien_ferm(META, ETQ) { } +function it_ouv(META, ETQ) { +} + +function it_ferm(META, ETQ) { +} + +function code_ouv(META, ETQ) { +} + +function code_ferm(META, ETQ) { +} + function liste_ouv(META, ETQ) { } diff --git a/lib/pres/gemtext.awk b/lib/pres/gemtext.awk @@ -80,6 +80,18 @@ function lien_ferm(META, ETQ) { ramasser("\n") } +function it_ouv(META, ETQ) { +} + +function it_ferm(META, ETQ) { +} + +function code_ouv(META, ETQ) { +} + +function code_ferm(META, ETQ) { +} + function liste_ouv(META, ETQ) { } diff --git a/lib/pres/html.awk b/lib/pres/html.awk @@ -5,12 +5,20 @@ BEGIN { f_css = "lib/style.css" } +function echapper_html(TEXTE) { + gsub(/&/, "\\&", TEXTE) + gsub(/</, "\\<", TEXTE) + gsub(/>/, "\\>", TEXTE) + + return TEXTE +} + function intervalle() { cesure = meta[metadonnees_trouver(meta, ":@:césure:$")] if (cesure == "pre") - ramasser(dechapper_pre($3)) + ramasser(echapper_html(dechapper_pre($3))) else - ramasser(dechapper_cont($3)) + ramasser(echapper_html(dechapper_cont($3))) } function doc_ouv(META, ETQ) { @@ -118,6 +126,22 @@ function lien_ferm(META, ETQ) { ramasser("</a><br>\n") } +function it_ouv(META, ETQ) { + ramasser("<em>") +} + +function it_ferm(META, ETQ) { + ramasser("</em>") +} + +function code_ouv(META, ETQ) { + ramasser("<code>") +} + +function code_ferm(META, ETQ) { + ramasser("</code>") +} + function liste_ouv(META, ETQ) { ramasser("<ul>\n") } diff --git a/lib/pres/pres.awk b/lib/pres/pres.awk @@ -18,6 +18,18 @@ etq(":lien:$") && ouvrante() { lien_ouv(meta, etiquette) } +etq(":it:$") && ouvrante() { + etiquette = $1 + metadonnees_lire(meta) + it_ouv(meta, etiquette) +} + +etq(":code:$") && ouvrante() { + etiquette = $1 + metadonnees_lire(meta) + code_ouv(meta, etiquette) +} + etq(":liste:$") && ouvrante() { etiquette = $1 metadonnees_lire(meta) @@ -67,6 +79,16 @@ etq(":lien:$") && fermante() { metadonnees_supp(meta, $1) } +etq(":it:$") && fermante() { + it_ferm(meta, $1) + metadonnees_supp(meta, $1) +} + +etq(":code:$") && fermante() { + code_ferm(meta, $1) + metadonnees_supp(meta, $1) +} + etq(":liste:$") && fermante() { liste_ferm(meta, $1) metadonnees_supp(meta, $1) diff --git a/liens/liens.aplat b/liens/liens.aplat @@ -0,0 +1,69 @@ +(doc + (lien (@ (id "ACCUEIL")) + "://asteride.xyz/~selve/") + (lien (@ (id "ART")) + "://asteride.xyz/~selve/articles/") + (lien (@ (id "FLO")) + "://asteride.xyz/~selve/florilege/") + (lien (@ (id "EXT_SOLDERPUNK_GIT_CONTENT_DISTRIBUTION")) + "gemini://gemini.circumlunar.space/~solderpunk/gemlog/low-budget-p2p-content-distribution-with-git.gmi") + (lien (@ (id "ART_JEX_CONSTRUCTION_PILE")) + "://asteride.xyz/~selve/articles/jex_construction_ideolangue_pile.") + (lien (@ (id "ART_FINGER_OPENBSD")) + "://asteride.xyz/~selve/articles/finger_openbsd.") + (lien (@ (id "ART_CATALAN_CURIOSITES")) + "://asteride.xyz/~selve/articles/curiosites_catalan.") + (lien (@ (id "ART_AYMARA_VOYELLES")) + "://asteride.xyz/~selve/articles/chute_voyelles_aymara.") + (lien (@ (id "ART_AVANT_PROPOS")) + "://asteride.xyz/~selve/articles/avant-propos.") + (lien (@ (id "ART_APLAT_1")) + "://asteride.xyz/~selve/articles/aplat_1_documents_structures_unix.") + (lien (@ (id "PAGE_A_VISITER")) + "://asteride.xyz/~selve/a_visiter.") + (lien (@ (id "PAGE_FLUX")) + "://asteride.xyz/~selve/flux/") + (lien (@ (id "FLUX_CYBERCARNET_GEMINI")) + "://asteride.xyz/~selve/flux/cybercarnet_gemini.atom") + (lien (@ (id "FLUX_CYBERCARNET_HTTP")) + "://asteride.xyz/~selve/flux/cybercarnet_http.atom") + (lien (@ (id "FLUX_CYBERCARNET_HTTPS")) + "://asteride.xyz/~selve/flux/cybercarnet_https.atom") + (lien (@ (id "MAN_APLAT_1")) + "://asteride.xyz/~selve/man/aplat.1.txt") + (lien (@ (id "MAN_APLAT_5")) + "://asteride.xyz/~selve/man/aplat.5.txt") + (lien (@ (id "MAN_PLAT_5")) + "://asteride.xyz/~selve/man/plat.5.txt") + (lien (@ (id "PUB_APLAT")) + "://asteride.xyz/~selve/publications/aplat/aplat.tgz") + (lien (@ (id "SITEMAP.TXT")) + "://asteride.xyz/~selve/sitemap.txt") + (lien (@ (id "HUMANS.TXT")) + "://asteride.xyz/~selve/humans.txt") + (lien (@ (id "ROBOTS.TXT")) + "://asteride.xyz/~selve/robots.txt") + (lien (@ (id "EXT_GAMIFICAT")) + "://gamifi.cat/") + (lien (@ (id "EXT_SI3TCH")) + "://si3t.ch/") + + (si (@ (#proto=gemini + (lien (@ (id "EXT_SOLENE")) + "://perso.pw/blog/") + (lien (@ (id "GIT_APLAT")) + "https://git.asteride.xyz/~selve/aplat/") + (lien (@ (id "GIT_CAPSITE")) + "https://git.asteride.xyz/~selve/capsite/")))) + + (si (@ (#proto=http|proto=https + (lien (@ (id "EXT_SOLENE")) + "://dataswamp.org/~solene/") + (lien (@ (id "ART_AVANT_PROPOS")) + "://asteride.xyz/~selve/articles/avant-propos.html") + (lien (@ (id "GIT_APLAT")) + "://git.asteride.xyz/~selve/aplat/") + (lien (@ (id "GIT_CAPSITE")) + "://git.asteride.xyz/~selve/capsite/") + (lien (@ (id "ART_A_VISITER")) + "://asteride.xyz/~selve/articles/a_visiter.html"))))) diff --git a/liens/liens.debout b/liens/liens.debout @@ -1,55 +0,0 @@ -(doc - (lien (@ (id "ACCUEIL")) - "://asteride.xyz/~selve/") - (lien (@ (id "ART")) - "://asteride.xyz/~selve/articles/") - (lien (@ (id "FLO")) - "://asteride.xyz/~selve/florilege/") - (lien (@ (id "EXT_SOLDERPUNK_GIT_CONTENT_DISTRIBUTION")) - "gemini://gemini.circumlunar.space/~solderpunk/gemlog/low-budget-p2p-content-distribution-with-git.gmi") - (lien (@ (id "ART_JEX_CONSTRUCTION_PILE")) - "://asteride.xyz/~selve/articles/jex_construction_ideolangue_pile.") - (lien (@ (id "ART_FINGER_OPENBSD")) - "://asteride.xyz/~selve/articles/finger_openbsd.") - (lien (@ (id "ART_CATALAN_CURIOSITES")) - "://asteride.xyz/~selve/articles/curiosites_catalan.") - (lien (@ (id "ART_AYMARA_VOYELLES")) - "://asteride.xyz/~selve/articles/chute_voyelles_aymara.") - (lien (@ (id "ART_AVANT_PROPOS")) - "://asteride.xyz/~selve/articles/avant-propos.") - (lien (@ (id "PAGE_A_VISITER")) - "://asteride.xyz/~selve/a_visiter.") - (lien (@ (id "PAGE_FLUX")) - "://asteride.xyz/~selve/flux/") - (lien (@ (id "FLUX_CYBERCARNET_GEMINI")) - "://asteride.xyz/~selve/flux/cybercarnet_gemini.atom") - (lien (@ (id "FLUX_CYBERCARNET_HTTP")) - "://asteride.xyz/~selve/flux/cybercarnet_http.atom") - (lien (@ (id "FLUX_CYBERCARNET_HTTPS")) - "://asteride.xyz/~selve/flux/cybercarnet_https.atom") - (lien (@ (id "SITEMAP.TXT")) - "://asteride.xyz/~selve/sitemap.txt") - (lien (@ (id "HUMANS.TXT")) - "://asteride.xyz/~selve/humans.txt") - (lien (@ (id "ROBOTS.TXT")) - "://asteride.xyz/~selve/robots.txt") - (lien (@ (id "EXT_GAMIFICAT")) - "://gamifi.cat/") - (lien (@ (id "EXT_SI3TCH")) - "://si3t.ch/") - - (si (@ (#proto=gemini - (lien (@ (id "EXT_SOLENE")) - "://perso.pw/blog/") - (lien (@ (id "GIT_CAPSITE")) - "https://git.asteride.xyz/~selve/capsite/")))) - - (si (@ (#proto=http|proto=https - (lien (@ (id "EXT_SOLENE")) - "://dataswamp.org/~solene/") - (lien (@ (id "ART_AVANT_PROPOS")) - "://asteride.xyz/~selve/articles/avant-propos.html") - (lien (@ (id "GIT_CAPSITE")) - "://git.asteride.xyz/~selve/capsite/") - (lien (@ (id "ART_A_VISITER")) - "://asteride.xyz/~selve/articles/a_visiter.html"))))) diff --git a/src/a_visiter.dbt b/src/a_visiter.aplat diff --git a/src/articles/aplat_1_documents_structures_unix.aplat b/src/articles/aplat_1_documents_structures_unix.aplat @@ -0,0 +1,311 @@ +(doc + (@ (type "article") + (titre "aplat(1) : documents structurés pour Unix") + (date-pub "2024-01-25") + (auteur "Selve") + (lien:ref-std "ART_APLAT_1") + (uuid "89352ae7-b5d5-4c87-bf51-edd280ae0c62")) + +(par "Les utilitaires classiques de Unix se prêtent très bien à la manipulation +de données structurées par des listes ou par des tableaux, c’est-à -dire à la +manipulation de données qu’on encode aisément avec des lignes et des champs. Un +bon nombre de ces utilitaires (grep, sed, awk, cut, sort, diff, uniq, etc.) ont +en effet été conçus spécialement pour l’analyse et le traitement des données +ligne par ligne. Aussi, ils offrent souvent la possibilité de reconnaître des +segments de ligne séparés par un délimitateur arbitraire, faisant émerger ce +deuxième niveau d’organisation qu’est le champs.") + +(par "Il existe cependant d’autres types de strutures de données qu’on ne +représente pas instinctivement par ces éléments, et les utilitaires qui +s’attendent à trouver des données organisées ligne par ligne ont évidemment bien +souvent de la difficulté à traiter correctement les formats de document +structurés selon un autre principe. Parmi ces formats, on compte notamment le +XML, le TeX, le Markdown, etc., mais aussi le C, le Shell, le Scheme, etc. Parce +qu’ils supposent une structure au nombre de niveaux fixe et assez limité +(souvent deux : la ligne et le champ), ces utilitaires semblent parfaitement +inadaptés au traitement de ces autres formats, d’autant plus que plusieurs +d’entre eux ont une structure récursive, admettant donc un nombre illimité de +niveaux.") + +(par "Bien que, donc, les utilitaires de traitement de texte conçus pour bien +fonctionner dans un environnement de type Unix n’ont pas une portée absolument +générale, ils restent très utiles pour mener à bien un grand nombre de tâches. +Comme beaucoup d’autres, j’attribue cette utilité à leur simplicité, à leur +(relative) cohérence, à leur composabilité et à leur omniprésence. Je les trouve +en outre agréables à utiliser. Mais je ne venterai pas davantage leurs mérites, +car le programme informatique que cet article doit présenter s’adresse avant +tout à ceux que ces mérites séduisent déjà , surtout que ce programme est +parfaitement inutile lorsqu’utilisé seul et qu’il ne trouve sa valeur que dans +la coopérations avec ces autres utilitaires.") + +(par "Puisqu’il est de toute façon utile d’apprendre à maîtriser ces utilitaires +Unix et que je suis maintenant devenu à l’aise avec eux, je me suis donné pour +objectif d’étendre leur portée en créant un format de document structuré selon +le principe des lignes et des champs qui permettrait de représenter des données +structurées selon n’importe quel autre principe.") + +(par "Je présente ici le programme " (code "aplat(1)") " et les deux formats +qu’il utilise. Le programme lit en entrée standard un document dans un certain +format et exporte en sortie standard sa représentation dans un format pont +organisé selon des lignes et des champs.") + +(par "J’ai conçu le format de sortie pour qu’il soit facile pour les utilitaires +classiques de Unix de le manipuler. Puisqu’il présente la structure des +documents sous une forme applatie, j’ai décidé de lui donner le nom de " (it +"plat") ".") + +(par "J’ai conçu le format d’entrée pour qu’il soit facile pour une personne de +le manipuler. C’est un format beaucoup plus simple à comprendre et selon moi +beaucoup moins pénible à écrire à la main que le XML. Il s’inspire beaucoup du +SXML. Puisqu’il s’oppose en quelque sorte au format " (code "plat(5)") ", je lui ai +donné le nom de " (it "a") "plat " (it "(non-plat)")". Il s’agit d’un " (it "a") +" privatif, qu’un trouve par exemple dans des mots comme " (it "apatride") " ou +" (it "anonyme") ".") + +(par "Quant au programme, il se serait appelé " (it "à plat") " si la tradition +restreignait pas le nom des programmes à l’ensemble des suite de caractères +ASCII affichables. Sa tâche est en effet de passer d’" (code "aplat(5)") " " (it +"à ") " " (code "plat(5)")".") + + (section:code "aplat(5)") + +(par "Le format " (code "aplat(5)") " permet une organisation hiérarchique de +données étiquettées. Il est inspiré du SXML et est aussi puissant que lui. C’est +surtout pour des raisons de simplicité que j’ai choisi de créer un nouveau +format de document plutôt que d’en utiliser un qui existait déjà . Bien que cette +entreprise aurait été tout à fait possible, je ne voulais pas avoir à composer +avec la complexité du XML, par exemple. Aussi, la création d’un nouveau format +de toutes pièces donne une liberté bien plus grande. De toute façon, l’intérêt +d’" (code "aplat(1)") "se trouve selon moi bien plus dans son format de sortie +que dans son format d’entrée, et il est possible de créer un programme distinct +traduisant le XML, le SXML, le HTML ou n’importe quel autre format vers "(code +"plat(5)") ".") + +(par "Voici un exemple de document valide.") + +(par (@:césure "pre") +""" +(doc + (titre Un\ programme\ en\ C) + (auteur Selve) + (date-pub 2023 - 11 - 18) + (date-mod (vide)) + (par "Voici un exemple de document dans le format aplat.") + (lien + (url "https://asteride.xyz/~selve/exemple.txt") + (texte "Un exemple d’URL")) + (pre +"""! langue=C +#include <stdio.h> + +int +main(void) +{ + printf("Bonjour tout le monde!\n"); + return 0; +} +"""! + ) + (par "Ce paragraphe affiche " (it "Bonjour tout le monde!"))) +""") + +(par "Je veux faire quelques remarques sur le contenu de cet exemple. Sachez +cependant que cet article complète plutôt qu’il ne remplace les pages du manuel +livrées avec le programme.") + + (par (@:type "liens") + (lien (@:ref:ref-std "MAN_APLAT_1") + "aplat(1)") + (lien (@:ref:ref-std "MAN_APLAT_5") + "aplat(5)") + (lien (@:ref:ref-std "MAN_PLAT_5") + "plat(5)")) + +(par "La structure hiérarchique d’un document " (code "aplat(5)") " est +explicitée par les parenthèses qui encadrent une section de ce document. +J’appelle " (it "domaine") " l’espace se trouvant entre deux parenthèses de même +niveau.") + +(par "Un domaine, s’il n’est pas vide, est composé d’" (it "atomes") ". Un atome +est une chaîne de caractères séparés par une parenthèse ou par des blancs +(espaces, caractères de tabulation ou nouvelles lignes).") + +(par "Le premier atome d’un domaine correspond à l’" (it "étiquette") ". Il +nomme un domaine. Tous les autres atomes d’un même domaine sont comme concatenés +pour former une longue chaîne de caractères. Je nomme cette chaîne le " (it +"contenu") ". « " (code "doc") " », « " (code "titre") " », « " (code "auteur") +" », « " (code "vide") " », etc. sont tous des exemples d’étiquettes ; « " (code +"Selve") " » est un exemple de contenu. Aussi, notons que, puisque les atomes +adjacents sont concatenés, le segment « " (code "2023 - 11 - 18") " » correspond +à l’atome « " (code "2023-11-18") " ».") + +(par "Il est possible d’inclure des caractères spéciaux dans des atomes en les +échappant. Ils seront alors traités comme des caractères normaux.") + +(par "Il existe trois manières d’échapper des caractères spéciaux.") + +(par "D’abord, on peut utiliser la barre oblique inversée (« \\\\ »). Son effet +varie selon le caractère échappé. Les parenthèses, les espaces normaux, les +caractères de tabulation, les guillemets et le caractère d’échappement lui-même +sont interprétés dans leur sens littéral lorsque ce caractère les précède. +Cependant, une nouvelle ligne échappée est ignorée. Dans l’exemple ci-dessus, la +chaîne « " (code "Un\\ programme\\ en\\ C") " » est interprété comme un seul +atome et correspond à « Un programme en C ».") + +(par "Ensuite, on peut placer les caractères à échapper entre guillemets. Les +parenthèses et les blancs placés entre deux guillemets reçoivent leur +interprétation littérale. Par exemple, ici la chaîne « " (code "\"Voici un +exemple de document dans le format aplat.\"") " » forme un seul atome.") + +(par "Finalement, on peut créer un " (it "bloc") " en plaçant les caractères à +échapper entre deux triples guillemets droits doubles (« "(code \"\"\") " »). +Tous les caractères reçoivent alors leur interprétation littérale. À l’intérieur +d’un bloc, il est possible d’échapper la séquence « "(code \"\"\") " » en la +faisant suivre d’un point d’exclamation (« " (code \"\"\"!) " »).") + +(par "Tous les caractères entre la séquence d’ouverture d’un bloc et la première +nouvelle ligne, inclusivement sont ignorés. C’est pour faciliter le travail de +préprocesseurs, qui fonctionneront d’une manière analogue à ceux de troff. Ces +préprocesseurs, contrairement aux postprocesseurs, opéreront sur l’entrée de +aplat(1) plutôt que sur sa sortie. On pourra alors leur fournir de l’information +sur cette première ligne.") + +(par "Les blocs sont utiles pour inclure verbatim un bloc de texte, comme un +programme informatique ou un document HTML.") + + (section (@:niveau 2) "Métaformats") + +(par "À partir de cette description, il est possible — nécessaire, même — de +créer un métaformat adapté à certains besoins. Ainsi, on peut imaginer une +manière de représenter les métadonnées comme le fait le XML. Cette idée est +empruntée au SXML. Est une métadonnée (paire attribut-valeur) un domaines et son +contenu s’ils se trouvent à l’intérieur d’un domaine étiquetté avec « " (code @) +" ».") + +(par "Voici l’exemple précédent converti à cette convention.") + +(par (@:césure "pre") +""" +(doc + (@ (titre "Un programme en C") + (auteur "Selve") + (date-pub "2023-11-18") + (date-mod (vide)) + (métaformat "genre-de-sxml")) + (par "Voici un exemple de document dans le format aplat.") + (lien (@ (ref "https://asteride.xyz/~selve/exemple.txt")) + "Un exemple d’URL") + (pre +"""! lang=C +#include <stdio.h> + +int +main(void) +{ + printf("Bonjour tout le monde!\n"); + return 0; +} +"""! + ) + (par "Ce paragraphe affiche " (it "Bonjour tout le monde!"))) +""") + +(par "Ici, les attributs « " (code "titre") " », « " (code "auteur") " », « " +(code "date-pub") " », etc. portent sur le domaine nommé « " (code "doc") " » et +l’attribut « " (code "ref") " » porte sur celui nommé « " (code "lien") " ».") + + (section (code "plat(5)")) + +(par "Le format " (code "plat(5)") " est une représentation équivalente au " +(code "aplat(5)") ", au XML, etc.") + +(par "Voici la représentation en plat du dernier exemple en aplat.") + +(par (@:césure "pre") +""" +:doc: ( +:doc:@: ( +:doc:@:titre: () Un programme en C +:doc:@:auteur: () Selve +:doc:@:date-pub: () 2023-11-18 +:doc:@:date-mod: ( +:doc:@:date-mod:vide: () +:doc:@:date-mod: ) +:doc:@:métaformat: () genre-de-sxml +:doc:@: ) +:doc:par: () Voici un exemple de document dans le format aplat. +:doc:lien: ( +:doc:lien:@: ( +:doc:lien:@:ref: () https://asteride.xyz/~selve/exemple.txt +:doc:lien:@: ) +:doc:lien: ) Un exemple d’URL +:doc:pre: () #include <stdio.h>\n\nint\nmain(void)\n{\n\tprintf("Bonjour tout le monde!\\n");\n\treturn 0;\n} +:doc:par: ( Ce paragraphe affiche +:doc:par:it: () Bonjour tout le monde! +:doc:par: ) +:doc: ) +""") + +(par "Il est composé d’une série de lignes et de trois champs, séparés par des +caractères de tabulation.") + +(par "Le premier champ correspond au nom du domaine. Il prend la forme de la +liste des toutes les étiquettes des domaines parents, précédées d’un deux-points +(« : »). La dernière étiquette est aussi suivie d’un deux-points. Il n’est pas +possible d’échapper ce caractère, car plusieurs outils auraient du mal à +composer avec une telle syntaxe.") + +(par "J’appelle " (it "domaine cadet") " le domaine le plus imbriqué. Ainsi, à +la ligne commençant par « " (code ":doc:@:date-mod:vide:" ) " », le domaine +cadet est « " (code ":vide:") " », alors qu’à la première ligne le domaine cadet +est « " (code ":doc:") " ».") + +(par "Tout nom de domaine doit apparaître au moins une fois en position de +domaine cadet, et ce même s’il est vide. Par exemple, bien que « " (code ":@:") +" », dans le domaine « " (code ":doc:@:") " », ne renferme que d’autres +domaines, il a droit à sa ligne, de même que « " (code ":vide:")" ».") + +(par "Le second champ est une liste de drapeaux. Pour l’instant — et je ne pense +pas en ajouter de si tôt —, il en existe deux: la parenthèse ouvrante (« " (code +"(") " ») et la parenthèse fermante (« " (code ")") " »), dénotant +respectivement la limite initiale et la limite finale d’un domaine.") + +(par "Le troisième champ correspond au « contenu » du format " (code "aplat(5)") +".") + +(par (code "plat(5)") " est organisé selon le principe des lignes et des champs ; +les lignes sont séparées par le caractère de saut de ligne et les champs par +un caractère de tabulation. Pour utiliser ces caractères au sens propre, il +suffit de les échapper. On peut voir le mécanisme d’échappement à l’œuvre à la +ligne commençant par « " (code ":doc:pre:") " » dans l’exemple ci-dessus.") + + (section "Utilisation d’" (code "aplat(1)")) + +(par "Le programme " (code "aplat(1)") " ne lit aucun argument de ligne de +commande : ni options ni nom de fichier ; il se contente de lire en entrée +standard et d’écrire en sortie standard.") + +(par "Il s’ulitise donc de la manière suivante.") + +(par (@:césure "pre") +"$ aplat <entree.aplat >sortie.plat") + + (section "Conclusion") + +(par "J’ai créé cet utilitaire après de nombreuses heures de patentatage avec +les solutions existantes. Je cherchais un format de document sémantique qui soit +à la fois agréable à utiliser et qui s’intégre bien avec les utilitaires Unix. +Je suis content de dire que cette recherche est maintenant terminée ; je suis +satisfait de ma création.") + +(par "J’ai de nombreuses idées de programmes auxiliaires qui permettront de +faciliter l’utilisation des formats " (code "aplat(5)") " et " (code "plat(5)") +". Je leur dédirai certainement d’autres articles.") + + (section "Voir aussi") + + (par (@ (type "liens")) + (lien (@:ref:ref-std "PUB_APLAT") + "Télécharger " (code "aplat(1)")) + (lien (@:ref:ref-std "GIT_APLAT") + "Dépôt git du programme."))) diff --git a/src/articles/avant-propos.dbt b/src/articles/avant-propos.aplat diff --git a/src/articles/chute_voyelles_aymara.dbt b/src/articles/chute_voyelles_aymara.aplat diff --git a/src/articles/curiosites_catalan.dbt b/src/articles/curiosites_catalan.aplat diff --git a/src/articles/finger_openbsd.dbt b/src/articles/finger_openbsd.aplat diff --git a/src/articles/index.aplat b/src/articles/index.aplat @@ -0,0 +1,19 @@ +(doc + (@ (type "index") + (titre "Le Cybercarnet de Selve") + (lien (ref-std "ART")) + (uuid "7b0545e6-b168-492f-b3e0-58446ad824ea")) + +(par (@ (type "liens")) + (lien (@ (ref (ref-std "ART_APLAT_1"))) + "2024-01-25 aplat(1) : documents structurés pour Unix") + (lien (@ (ref (ref-std "ART_JEX_CONSTRUCTION_PILE"))) + "2023-05-07 Jex en construction : une idéolangue basée sur le principe de pile") + (lien (@ (ref (ref-std "ART_FINGER_OPENBSD"))) + "2023-02-11 Configurer un serveur finger sous OpenBSD") + (lien (@ (ref (ref-std "ART_CATALAN_CURIOSITES"))) + "2022-10-11 Quelques curiosités du catalan") + (lien (@ (ref (ref-std "ART_AYMARA_VOYELLES"))) + "2022-01-05 Chute de voyelles conditionnée morphologiquement en aymara") + (lien (@ (ref (ref-std "ART_AVANT_PROPOS"))) + "2021-12-21 Avant-propos"))) diff --git a/src/articles/index.dbt b/src/articles/index.dbt @@ -1,17 +0,0 @@ -(doc - (@ (type "index") - (titre "Le Cybercarnet de Selve") - (lien (ref-std "ART")) - (uuid "7b0545e6-b168-492f-b3e0-58446ad824ea")) - -(par (@ (type "liens")) - (lien (@ (ref (ref-std "ART_JEX_CONSTRUCTION_PILE"))) - "2023-05-07 Jex en construction : une idéolangue basée sur le principe de pile") - (lien (@ (ref (ref-std "ART_FINGER_OPENBSD"))) - "2023-02-11 Configurer un serveur finger sous OpenBSD") - (lien (@ (ref (ref-std "ART_CATALAN_CURIOSITES"))) - "2022-10-11 Quelques curiosités du catalan") - (lien (@ (ref (ref-std "ART_AYMARA_VOYELLES"))) - "2022-01-05 Chute de voyelles conditionnée morphologiquement en aymara") - (lien (@ (ref (ref-std "ART_AVANT_PROPOS"))) - "2021-12-21 Avant-propos"))) diff --git a/src/articles/jex_construction_ideolangue_pile.dbt b/src/articles/jex_construction_ideolangue_pile.aplat diff --git a/src/florilege/index.dbt b/src/florilege/index.aplat diff --git a/src/flux/cybercarnet.special.dbt b/src/flux/cybercarnet.special.aplat diff --git a/src/flux/index.dbt b/src/flux/index.aplat diff --git a/src/humans.special.dbt b/src/humans.special.aplat diff --git a/src/index.dbt b/src/index.aplat diff --git a/src/man/aplat.1.txt.cp b/src/man/aplat.1.txt.cp @@ -0,0 +1,43 @@ +APLAT(1) Manuel des commandes générales APLAT(1) + +NOM + aplat – Convertir le format aplat au format plat + +SYNOPSIS + aplat <fichier + +DESCRIPTION + L'utilitaire aplat lit en entrée standard et écrit en sortie standard; il + n'accepte ni option ni argument. Il convertit le format aplat(5) au + format plat(5). + +EXEMPLES + En supposant que le fichier exemple.aplat a le contenu suivant : + + (doc + (@ (titre "Exemple") + (date "2024-01-21")) + (par "Voici un exemple.")) + + La commande suivante affiche le texte suivant : + + $ aplat <exemple.aplat + :doc: ( + :doc:@: ( + :doc:@:titre: () Exemple + :doc:@:date: () 2024-01-21 + :doc:@: ) + :doc:par: () Voici un exemple. + :doc: ) + +ÃÉTATS DE SORTIE + L'utilitaire aplat quitte avec 0 si tout s'est bien passé et avec >0 si + une erreur est survenue. + +VOIR AUSSI + aplat(5), plat(5) + +AUTEURS + Selve <selve@asteride.xyz> + + 23 janvier 2024 diff --git a/src/man/aplat.5.txt.cp b/src/man/aplat.5.txt.cp @@ -0,0 +1,106 @@ +APLAT(5) Manuel des formats de fichier APLAT(5) + +NOM + aplat – Format de document structuré hiérarchiquement + +DESCRIPTION + aplat est un format de document structuré hiérarchiquement conçu pour + être facile à manipuler, aussi bien par un humain que par une machine. + + C'est le format qu'aplat(1) prend en entrée. + + Le format aplat est constitué de quatre types d'objet : domaine, atome, + étiquette et contenu. + + Un domaine sectionne un document. Ses limites sont notées par des + parenthèses : les parenthèses ouvrante (‘(’) et fermante (‘)’) en + marquent le début et la fin, respectivement. Les limites de tout domaine + (et plus généralement, de tout object) doivent être contenues à + l'intérieur du domaine parent immédiat. Le domaine racine, domaine + absolument supérieur en ce qu'il n'a pas de parent et qu'il contient tous + les autres domaines, fait exception à la règle. Il va de soi que les + parenthèses de tout domaine doivent être équilibrées. + + Lorsque l'étendue d'un domaine est la même que celle de son parent + immédiat, il est possible d'utiliser le raccourcis syntaxique noté par un + deux-points (‘:’). Dans cette notation, à gauche du deux-points se + trouve le domaine parent et à droite, le domaine enfant. Il est possible + d'ajouter de la sorte autant de domaines qu'on le souhaite, et que le + permet la quantité mémoire disponible sur le système. + + Ces deux constructions sont donc équivalentes : + + (parent + (intermédiaire + (enfant "Contenu du domaine"))) + + (parent:intermédiaire:enfant "Contenu du domaine") + + Une étiquette nomme un domaine. Ce nom correspond au premier atome du + domaine, à moins que le raccourcit syntaxique des deux-points ne soit + utilisé. En fait, on peut dire que le premier atome contient une + étiquette de plus que de deux-points. Ainsi, dans l'exemple ci-dessus, + parent, intermédiaire et enfant sont des étiquettes. + + Le contenu d'un domaine correspond la concaténation de tous les atomes + qu'il contient, excepté le premier, qui est l'étiquette. + + Finalement, un atome est une suite de caractères séparées par des + parenthèses ou par des blancs. Sont traités comme des blancs les + caractères suivants : l'espace normale (‘ ’), le saut de ligne (‘\n’) et + le caractère de tabulation (‘\t’). + + Il existe trois moyens d'échapper des caractères : l'utilisation de la + barre oblique inversée (‘\\’), l'encadrement avec des guillemets droits + doubles (‘"’) et l'encadrement avec une suite de trois de ces guillemets + (‘"""’). + + Le caractère d'échappement (‘\’) change l'interprétation des caractères + spéciaux. Son effet varie selon le caractère échappé. Les parenthèses, + les espaces normaux, les caractères de tabulation, les guillemets et le + caractère d'échappement lui-même sont interprétés dans leur sens littéral + lorsque ce caractère les précède. Cependant, une nouvelle ligne échappée + est ignorée, et l'échappement de tout autre caractère est équivalent à ce + même caractère sans échappement. + + Lorsqu'une chaîne de caractères est placée entre guillemets droits + doubles (‘"’), les blancs et les parenthèses recoivent leur + interprétation littérale. Le comportement du caractère d'échappement est + le même à l'intérieur de guillemets qu'à l'extérieur. Les guillemets + n'ont pas à se trouver aux extrémités des atomes mais fonctionnent plutôt + comme des commutateurs réglant le mode d'interprétation. Ils + fonctionnent en cela comme les guillemets des interpréteurs de commandes + Unix. + + La dernière stratégie d'échappement a recourt à un bloc. Un bloc est + délimité par une paire de triples guillemets droits doubles (‘"""’). Les + caractères qui se trouvent entre le triplet ouvrant et la première + nouvelle ligne (‘\n’), inclusivement, et ceux qui se trouvent entre la + dernière nouvelle ligne et le triplet fermant, inclusivement, sont + ignorés. Ces caractères ignorés peuvent servir à donner certaines + informations à d'éventuels préprocesseurs. Le texte qui se trouve à + l'intérieur d'un bloc est interprété verbatim. Une construction spéciale + permet d'y inclure une suite de trois guillemets. Il suffit de les faire + suivre d'un point d'exclamation (‘!’) + + Ainsi, les trois constructions suivantes sont équivalentes : + + (doc + (par Un\ bloc\ est\ limité\ par\ la\ suite\ \"\"\"\.)) + + (doc + (par "Un bloc est limité par la suite\"\"\".")) + + (doc + (par + """ type=texte + Un bloc est limité par la suite """!. + """)) + +VOIR AUSSI + aplat(1), plat(5) + +AUTEURS + Selve <selve@asteride.xyz> + + 23 janvier 2024 diff --git a/src/man/plat.5.txt.cp b/src/man/plat.5.txt.cp @@ -0,0 +1,67 @@ +PLAT(5) Manuel des formats de fichier PLAT(5) + +NOM + plat – Format de document structuré hiérarchiquement pour Unix + +DESCRIPTION + plat est un format de document organisé en lignes et en champs qui permet + la représentation de structures hiérarchiques. Les utilitaires de + traitement de texte conçus pour bien fonctionner dans un environnement + Unix sont donc tout à fait capables de le manipuler. + + Le format se présente comme une suite de lignes, chacune séparée en trois + champs : celui des étiquettes, celui des drapeaux et celui du contenu. + Les champs sont séparés par des caractères de tabulation (‘\t’). + + Un domaine sectionne un document plat. Les limites de tout domaine sont + contenues à l'intérieur du domaine parent immédiat. Le domaine racine, + domaine absolument supérieur en ce qu'il n'a pas de parent et qu'il + contient tous les autres domaines, fait exception à la règle. Le domaine + cadet est le domaine le plus imbriqué à un endroit donné du document. + Tout domaine apparaît au moins une fois en position de domaine cadet, et + ce même s'il est vide. + + Une étiquette nomme un domaine. Le champ des étiquettes contient + l'étiquette du domaine cadet courant de même que, le cas échéant, les + étiquettes de tous ses domaines parents. Ce champ a la forme d'une liste + d'étiquettes ordonnée de telle sorte qu'un parent se trouve toujours à la + gauche de son enfant. Chaque étiquette de cette liste est précédée d'un + deux-points (‘:’). La dernière étiquette est aussi suivie d'un deux- + points. Il est impossible d'échapper les deux-points dans ce champ. + + Un drapeau permet d'identifier les limites d'un domaine. La parenthèse + ouvrante (‘(’) indique que la ligne est la première à être incluse dans + un domaine donné; la parenthèse fermante (‘)’) indique que la ligne est + la dernière à être incluse dans un domaine donné. + + Les champs contenu qui se suivent et qui appartiennent à un même domaine + cadet sont concatenés. + + Les lignes étant séparées par des nouvelles lignes (‘\n’) et les champs + par des caractères de tabulation (‘\t’), ces caractères sont échappés par + ‘\n’ et ‘\t’, respectivement. Le caractère d'échappement lui-même peut + être échappé par ‘\\’. + +EXEMPLES + L'exemple suivant (où un signe de dollar a été ajouté pour marquer la fin + de la ligne) : + + :doc: ( $ + :doc:par: ( Que veut $ + :doc:par: dire $ + :doc:par:it: () placoter$ + :doc:par: )  ?$ + :doc: ) $ + + est tout à fait équivalent au document aplat(5) suivant : + + (doc + (par "Que veut dire " (it "placoter") " ?")) + +VOIR AUSSI + aplat(1), aplat(5) + +AUTEURS + Selve <selve@asteride.xyz> + + 23 janvier 2024 diff --git a/src/publications/aplat/aplat-1.0.tgz.cp b/src/publications/aplat/aplat-1.0.tgz.cp Binary files differ. diff --git a/src/publications/aplat/aplat.tgz.cp b/src/publications/aplat/aplat.tgz.cp Binary files differ. diff --git a/src/robots.special.dbt b/src/robots.special.aplat