| PO4A(7) | Po4a-hulpmiddelen | PO4A(7) |
po4a - raamwerk voor de vertaling van documentatie en ander materiaal
po4a (PO voor alles) vergemakkelijkt het onderhoud van de vertaling van documentatie via het gebruik van het klassieke gettext-gereedschap. De belangrijkste eigenschap van po4a is dat het de vertaling van de inhoud loskoppelt van de structuur van het document.
Dit document dient als een inleiding tot het po4a-project met een focus op potentiële gebruikers die zich afvragen of ze dit hulpmiddel zouden gebruiken, en op nieuwsgierigen die willen begrijpen waarom de dingen zijn zoals ze zijn.
De filosofie van Vrije Software is om de technologie echt voor iedereen beschikbaar te maken. Maar het licentie-aspect is niet het enige om in overweging te nemen: voor niet-Engelstaligen is niet-vertaalde software nutteloos. Daarom hebben we nog steeds wat werk te doen om software voor iedereen beschikbaar te maken.
Door de meeste projecten wordt deze situatie goed begrepen en iedereen is nu overtuigd van de noodzaak om alles te vertalen. Niettemin betekent het eigenlijke vertaalwerk een geweldige inspanning voor veel individuen, gehandicapt door kleine technische moeilijkheden.
Gelukkig wordt opensourcesoftware eigenlijk heel goed vertaald met behulp van de gettext gereedschapssuite. Dit gereedschap wordt gebruikt om de te vertalen tekstfragmenten uit een programma te extraheren en deze te vertalen tekstfragmenten aan te bieden in een gestandaardiseerde indeling (PO-bestanden genoemd, ofwel vertaalcatalogus). Een heel ecosysteem hulpmiddelen is ontstaan om vertalers te helpen bij het daadwerkelijk vertalen van deze PO-bestanden. Het resultaat wordt vervolgens door gettext gebruikt om tijdens de programmauitvoering de vertaalde berichten aan de eindgebruiker te tonen.
Met betrekking tot documentatie is de situatie nog steeds enigszins ontgoochelend. Op het eerste gezicht lijkt het vertalen van documentatie makkelijker dan een programma vertalen, aangezien het erop lijkt dat je gewoon het bronbestand met de documentatie moet kopiëren en moet beginnen met het vertalen van de inhoud. Wanneer aan de originele documentatie echter aanpassingen gemaakt worden, wordt het bijhouden van de wijzigingen al snel een nachtmerrie voor de vertalers. Indien deze taak manueel moet gebeuren is ze onaangenaam en foutgevoelig.
Verouderde vertalingen zijn vaak erger dan helemaal geen vertaling. Eindgebruikers kunnen misleid worden door documentatie die een verouderd gedrag van het programma beschrijft. Bovendien kunnen zij niet rechtstreeks in interactie treden met de onderhouders, omdat zij geen Engels spreken. Daarenboven kan de onderhouder het probleem niet oplossen, aangezien deze niet elke taal kan kennen waarin de documentatie vertaald werd. Deze moeilijkheden, vaak veroorzaakt door slecht gereedschap, kan de motivatie van vertaalvrijwilligers ondermijnen en zo leiden tot een verdere verergering van het probleem.
Het doel van het po4a-project is om het werk van documentatievertalers te vergemakkelijken. In het bijzonder maakt het documentatievertalingen onderhoudbaar.
Het idee bestaat erin de gettext-aanpak te hergebruiken en aan te passen aan deze sector. Zoals dat met gettext het geval is, worden teksten geëxtraheerd uit hun originele locatie en aan vertalers voorgelegd als PO-vertaalcatalogi. De vertalers kunnen gebruik maken van het klassieke gettext-gereedschap om het te presteren werk op te volgen, om samen te werken en zich als team te organiseren. Daarna injecteert po4a de vertalingen rechtstreeks in de structuur van de documentatie om vertaalde bronbestanden te produceren die verwerkt en verspreid kunnen worden, net als de Engelse bestanden. Elke onvertaalde paragraaf blijft in het uiteindelijke document in het Engels staan, zodat er voor gezorgd wordt dat de eindgebruiker nooit een verouderde vertaling te zien krijgt in de documentatie.
Dit automatiseert het grootste deel van het zware werk van het onderhoud van vertalingen. Te weten komen welke paragrafen bijgewerkt moeten worden, wordt erg makkelijk, en het proces van het herordenen van elementen zonder dat er verder iets wijzigt, verloopt volledig automatisch. Ook kan specifieke verificatie toegepast worden om de kans op opmaakfouten, welke tot een defect document zouden leiden, te verkleinen.
Raadpleeg ook de FAQ verder in dit document, voor een meer volledige lijst van de voor- en nadelen van deze aanpak.
Momenteel werd deze aanpak met succes toegepast voor verschillende soorten tekstopmaakindelingen:
De module Locale::Po4a::Man(3pm) ondersteunt ook de mdoc-indeling, welke door de BSD man-pagina's gebruikt wordt (deze zijn ook redelijk gebruikelijk onder Linux).
Zie Locale::Po4a::AsciiDoc voor details.
Zie Locale::Po4a::Pod voor details.
Momenteel worden enkel DebianDoc en DocBook DTD ondersteund, maar iets anders ondersteunen is erg gemakkelijk. Het is zelfs mogelijk om zonder de code te wijzigen po4a te gebruiken bij een onbekende SGML DTD door de nodige informatie op te geven aan de commandoregel. Zie Locale::Po4a::Sgml(3pm) voor details.
De module Locale::Po4a::LaTeX(3pm) werd getest met de Python-documentatie , een boek en enkele presentaties.
Dit ondersteunt de indeling die Static Site Generators, README's en andere documentatiesystemen gebruiken en gemeen hebben.
Momenteel worden DocBook DTD (zie Locale::Po4a::Docbook(3pm) voor details) en XHTML door po4a ondersteund.
Zie Locale::Po4a::BibTex voor details.
Zie Locale::Po4a:Docbook voor meer details.
Zie Locale::Po4a:Guide voor meer details.
Zie Locale::Po4a::Wml voor meer details.
Zie Locale::Po4a::Yaml voor meer details.
Zie Locale::Po4a::RubyDoc voor meer details.
Zie Locale::Po4a:Halibut voor meer details.
Zie Locale::Po4a::Ini voor meer details.
Oorspronkelijk werd po4a gebouwd rond vier scripts, welke elk een specifieke taak vervullen. po4a-gettextize(1) helpt bij het opstarten van vertalingen en eventueel bij het converteren van bestaande vertaalprojecten naar po4a. po4a-updatepo(1) reflecteert de wijzigingen in de originele documentatie in de overeenkomstige po-bestanden. po4a-translate(1) bouwt een vertaald bronbestand uit de originele documentatie en het overeenkomstige PO-bestand. Daarnaast is er po4a-normalize(1) dat vooral nuttig is voor het debuggen van de po4a-ontleders, omdat het een onvertaald document produceert vanuit het origineel. Het maakt het gemakkelijker om de door het parser-proces veroorzaakte probleempjes op te sporen.
De meeste projecten hebben enkel de functionaliteit van po4a-updatepo(1) en po4a-translate(1) nodig, maar deze scripts bleken in het gebruik omslachtig en foutgevoelig te zijn. Indien de te vertalen documentatie opgesplitst is in verschillende bronbestanden, is het moeilijk om de PO-bestanden up-to-date te houden en de documentatiebestanden correct te bouwen. Als antwoord hierop wordt een alles-in-ééngereedschap aangereikt: po4a(1). Dit gereedschap vertrekt van een configuratiebestand dat de structuur van het vertaalproject beschrijft: de locatie van de PO-bestanden, de lijst van de te vertalen bestanden en de te gebruiken opties, en het automatiseert dit proces volledig. Wanneer u po4a(1) uitvoert, werkt het niet enkel de PO-bestanden bij, maar het regenereert ook de vertaalbestanden welke dit nodig hebben. Indien alles reeds up-to-date is, verandert po4a(1) geen enkel bestand.
In de rest van dit onderdeel vindt u een overzicht over hoe de scriptinterface van po4a wordt gebruikt. De meeste gebruikers zullen er waarschijnlijk de voorkeur aan geven het alles-in-ééngereedschap te gebruiken, dat beschreven wordt in de documentatie van po4a(1).
Het volgende schema geeft een overzicht van hoe elk po4a-script gebruikt kan worden. Hier is hoofddocument.doc een voorbeeldnaam voor de te vertalen documentatie; XX.doc is hetzelfde document, vertaald in taal XX, terwijl doc.XX.po de vertaalcatalogus van dat document is in taal XX. Auteurs van documentatie zullen zich hoofdzakelijk bezighouden met hoofddocument.doc (dit kan een man-pagina zijn, een XML-document, een asciidoc-bestand of iets dergelijks). De vertalers zullen zich hoofdzakelijk bezighouden met het PO-bestand, terwijl de eindgebruikers uitsluitend het bestand XX.doc zullen zien.
hoofddocument.doc
|
V
+<-----<----+<-----<-----<--------+------->-------->-------+
: | | :
{vertaling} | { update van hoofddocument.doc } :
: | | :
XX.doc | V V
(facultatief) | hoofddocument.doc ->-------->------>+
: | (nieuw) |
V V | |
[po4a-gettextize] doc.XX.po -->+ | |
| (oud) | | |
| ^ V V |
| | [po4a-updatepo] |
V | | V
vertaling.pot ^ V |
| | doc.XX.po |
| | (onnauwkeurig) |
{ vertaling } | | |
| ^ V V
| | {handmatig bewerken} |
| | | |
V | V V
doc.XX.po --->---->+<---<-- doc.XX.po addendum hoofddocument.doc
(initieel) (up-to-date) (facultatief) (up-to-date)
: | | |
: V | |
+----->----->----->------> + | |
| | |
V V V
+------>-----+------<------+
|
V
[po4a-translate]
|
V
XX.doc
(up-to-date)
Dit schema is gecompliceerd, maar in de praktijk wordt enkel het rechterdeel gebruikt (waarbij po4a-updatepo(1) en po4a-translate(1) betrokken zijn) nadat het project opgezet en geconfigureerd is.
Het linkerdeel laat zien hoe po4a-gettextize(1) kan worden gebruikt om een bestaand vertaalproject te converteren naar de po4a-infrastructuur. Dit script gebruikt een origineel document en zijn vertaalde tegenhanger en tracht het overeenkomstige PO-bestand te bouwen. Een dergelijke handmatige conversie is nogal omslachtig (zie de documentatie over po4a-gettextize(1) voor meer details), maar ze moet slechts eenmaal gebruikt worden om uw bestaande vertalingen om te zetten. Indien u geen te converteren vertalingen heeft, kunt u dit vergeten en u concentreren op het rechterdeel van het schema.
In de rechterbovenhoek wordt de actie van de oorspronkelijke auteur afgebeeld, welke de documentatie bijwerkt. Het middelste rechterdeel geeft de automatische acties van po4a-updatepo(1) weer. Het nieuwe materiaal wordt geëxtraheerd en vergeleken met de bestaande vertaling. De vorige vertaling wordt gebruikt voor de delen welke niet gewijzigd werden, terwijl de gedeeltelijk gewijzigde delen gekoppeld worden aan de vorige vertaling met de aanduiding "fuzzy" (onnauwkeurig), hetgeen aangeeft dat de vertaling moet bijgewerkt worden. Nieuw of grondig gewijzigd materiaal blijft onvertaald.
Vervolgens geeft het gerapporteerde handmatig bewerken de actie van de vertalers weer, welke de PO-bestanden wijzigen om te voorzien in een vertaling voor elk origineel tekstfragment en alinea. Dit kan gebeuren met een specifieke editor, zoals de GNOME Translation Editor, KDE's Lokalize of poedit, of met een online lokalisatieplatform, zoals weblate of pootle. Het resultaat van de vertaling is een aantal PO-bestanden, één per taal. Raadpleeg de gettext-documentatie voor meer details.
Het onderste deel van de afbeelding toont hoe po4a-translate(1) een vertaald brondocument creëert uit het originele document hoofddocument.doc en de vertaalcatalogus doc.XX.po die door de vertalers bijgewerkt werd. De structuur van het document wordt hergebruikt, terwijl de originele inhoud vervangen wordt door de vertaalde tegenhanger. Facultatief kan een addendum gebruikt worden om aan de vertaling extra tekst toe te voegen. Dit wordt vaak gebruikt om de naam van de vertaler toe te voegen aan het uiteindelijke document. Zie hieronder voor details.
Zoals voordien reeds aangegeven werd, combineert het programma po4a(1) de effecten van de aparte scripts en werkt de PO-bestanden en het vertaalde document bij in één beweging. De onderliggende logica blijft dezelfde.
Indien u po4a(1) gebruikt, bestaat er geen specifieke stap voor het starten van een vertaling. U moet gewoon de talen vermelden in het configuratiebestand en de ontbrekende PO-bestanden worden automatisch gecreëerd. Natuurlijk moet de vertaler dan voor de vertaling zorgen van alle inhoud uit uw documenten. po4a(1) creëert ook een POT-bestand, hetgeen een PO-sjabloonbestand is. Potentiële vertalers kunnen uw project naar een nieuwe taal vertalen door dit bestand te hernoemen en te zorgen voor de vertaling ervan in hun taal.
Indien u verkiest om de individuele scripts apart te gebruiken, moet u po4a-gettextize(1) als volgt gebruiken om het POT-bestand te creëren. Dit bestand kan dan gekopieerd worden naar XX.po om een nieuwe vertaling te starten.
$ po4a-gettextize --format <indeling> --master <hoofddocument.doc> --po <vertaling.pot>
Het hoofddocument wordt als invoer gebruikt, terwijl het POT-bestand de uitvoer van dit proces is.
Het script dat daarvoor gebruikt moet worden is po4a-updatepo(1) (raadpleeg de erbij horende documentatie voor details):
$ po4a-updatepo --format <indeling> --master <nieuw_hoofddocument.doc> --po <oud_doc.XX.po>
Het hoofddocument wordt gebruikt als invoer, terwijl het PO-bestand bijgewerkt wordt: het wordt gebruikt als invoer en als uitvoer.
Als u klaar bent met de vertaling, wilt u de vertaalde documentatie nemen en deze samen met het origineel verdelen naar de gebruikers. Daarvoor moet u het programma po4a-translate(1) als volgt gebruiken:
$ po4a-translate --format <indeling> --master <hoofddocument.doc> --po <doc.XX.po> --localized <XX.doc>
Zowel het hoofddocument als de PO-bestanden worden als invoer gebruikt, terwijl het gelokaliseerde bestand de uitvoer is van dit proces.
Het toevoegen van nieuwe tekst aan de vertaling is waarschijnlijk het enige dat op de lange termijn gemakkelijker is wanneer u bestanden handmatig vertaalt :). Dit gebeurt wanneer u een extra onderdeel wilt toevoegen aan het vertaalde document, waarvoor in het originele document geen overeenkomstige inhoud bestaat. Het klassieke toepassingsgebied is erkenning geven aan het vertaalteam en aangeven hoe vertaalspecifieke problemen gemeld kunnen worden.
Met po4a moet u addendum-bestanden opgeven, die conceptueel beschouwd kunnen worden als patches die na verwerking toegepast worden op het gelokaliseerde document. Elk addendum moet als apart bestand aangereikt worden. De indeling ervan verschilt evenwel erg van klassieke patches. De eerste regel is een header-regel, die het invoegpunt van het addendum definieert (met een helaas cryptische syntaxis -- zie hieronder), terwijl de rest van het bestand woordelijk toegevoegd wordt op de aangegeven positie.
De header-regel moet beginnen met de tekst PO4A-HEADER:, gevolgd door een door puntkomma's gescheiden lijst van I <sleutel> B <=> I <waarde> velden.
Bijvoorbeeld, de volgende header declareert een addendum dat helemaal aan het einde van de vertaling geplaatst moet worden.
PO4A-HEADER: mode=eof
De zaken zijn complexer wanneer u de extra inhoud wilt toevoegen in het midden van het document. De volgende header declareert bijvoorbeeld een addendum dat ingevoegd moet worden na de XML-sectie welke het tekstfragment "Over dit document" bevat in de vertaling.
PO4A-HEADER: position=About this document; mode=after; endboundary=</section>
Wanneer po4a tracht een addendum toe te passen, zoekt het in de praktijk naar de eerste regel die overeenkomt met het "position"-argument (dit kan een reguliere expressie zijn). Vergeet niet dat po4a hier rekening houdt met het vertaalde document. Deze documentatie is in het Nederlands (en de originele versie ervan in het Engels), maar uw regel zou er waarschijnlijk als volgt moeten uitzien, indien u van plan bent een addendum toe te passen op de Franse vertaling van het document.
PO4A-HEADER: position=À propos de ce document; mode=after; endboundary=</section>
Nadat in het doeldocument de "position" gevonden werd, zoekt po4a naar de eerstvolgende regel na deze "position" welke overeenkomt met de opgegeven "endboundary". Het addendum wordt ingevoegd net na deze regel (omdat we een endboundary opgaven, d.w.z. een begrenzing die de huidige sectie afsluit).
Exact hetzelfde effect kan bekomen worden met de volgende header, die gelijkwaardig is:
PO4A-HEADER: position=Over dit document; mode=after; beginboundary=<section>
Hier zoekt po4a naar de eerste regel die overeenkomt met "<section"> na de regel die overeenkomt met "Over dit document" in de vertaling en voegt het addendum toe voor die regel, omdat we een beginboundary opgegeven hebben, d.w.z. een begrenzing welke het begin van de volgende sectie markeert. Deze header-regel vereist dus dat het addendum geplaatst wordt na de sectie waarin "Over dit document" voorkomt, en informeert po4a dat een sectie begint met een regel welke de tag "<section"> bevat. Dit is het equivalent van het vorige voorbeeld, want wat u eigenlijk wilt is het addendum in te voegen na "</section"> en voor "<section">.
U kunt de invoeging mode ook instellen op de waarde "before", met een vergelijkbare semantiek: het combineren van "mode = before" met een "endboundary" zal het addendum juist na de overeenkomstige begrenzing plaatsen, welke de laatst mogelijke begrenzing is voor de "position". De combinatie van "mode = before" met een "beginboundary" zal het addendum juist voor de overeenkomstige begrenzing plaatsen, welke de laatst mogelijke grensregel is vóór de "position".
Modus | Soort begrenzing | Gebruikte begrenzing | Invoegpunt tegenover begrenzing ========|===============|========================|========================================= 'before'| 'endboundary' | laatste voor 'position' | Juist na de geselecteerde begrenzing 'before'|'beginboundary'| laatste voor 'position' | Juist voor de geselecteerde begrenzing 'after' | 'endboundary' | eerste na 'position' | Juist na de geselecteerde begrenzing 'after' |'beginboundary'| eerste na 'position' | Juist voor de geselecteerde begrenzing 'eof' | (geen) | n.v.t. | Einde van het bestand
Aanwijzingen en kneepjes in verband met addenda
PO4A-HEADER: position=Over dit document; mode=after; beginboundary=<section>
PO4A-HEADER: position=Over dit document ; mode=after; beginboundary=<section>
Voorbeelden van addenda
.SH "AUTEURS"
U moet een benadering in twee stappen selecteren door mode = after in te stellen. Vervolgens moet u de zoekopdracht beperken tot de regel na AUTEURS met de reguliere expressie voor het argument position. Daarna moet u het begin van de volgende sectie (d.w.z. ^\.SH) laten opzoeken met de reguliere expressie voor het argument beginboundary. Het is te zeggen:
PO4A-HEADER:mode=after;position=AUTEURS;beginboundary=\.SH
PO4A-HEADER:mode=after;position=Copyright Grote Kerel, 2004;beginboundary=^
PO4A-HEADER:mode=after;position=Over dit document;beginboundary=VerzonnenPo4aBegrenzing
Een meer gedetailleerd voorbeeld
Origineel document (POD-indeling):
|=head1 NAAM | |dummy - een dummy-programma | |=head1 AUTEUR | |ik
Dan zal het volgende addendum ervoor zorgen dat een sectie (in het Frans) over de vertaler toegevoegd wordt aan het eind van het bestand ("TRADUCTEUR" in het Frans betekent "VERTALER", en "moi" betekent "ik").
|PO4A-HEADER:mode=after;position=AUTEUR;beginboundary=^=head | |=head1 TRADUCTEUR | |moi |
Om uw addendum voor de AUTEUR te plaatsen, gebruikt u de volgende header:
PO4A-HEADER:mode=after;position=NAAM;beginboundary=^=head1
Dit werkt omdat de volgende regel die overeenkomt met de beginboundary /^=head1/ na de sectie "NAME" (vertaald als "NAAM" in het Nederlands), die is welke de auteurs vermeldt. Dus zal het addendum tussen de beide secties geplaatst worden. Merk op dat indien later een andere sectie toegevoegd wordt tussen de secties NAAM en AUTEUR, po4a de addenda ten onrechte zal plaatsen voor de nieuwe sectie.
Om dit te vermijden, kunt u hetzelfde bereiken met behulp van mode=before:
PO4A-HEADER:mode=before;position=^=head1 AUTEUR
Dit hoofdstuk geeft u een kort overzicht van de binnenkant van po4a, zodat u met meer zelfvertrouwen ons kunt helpen het te onderhouden en te verbeteren. Het kan u ook helpen te verstaan waarom het niet doet wat u verwachtte en hoe u uw problemen kunt oplossen.
De po4a-architectuur is objectgeoriënteerd. De klasse Locale::Po4a::TransTractor(3pm) is de gemeenschappelijke voorouder van alle po4a-ontleders. Deze vreemde naam komt door het feit dat het tegelijk belast is met de vertaling van het document en het extraheren van tekstfragmenten.
Meer formeel neemt het als invoer een te vertalen document plus een PO-bestand dat de te gebruiken vertalingen bevat en produceert het twee aparte uitvoerbestanden: een ander PO-bestand (als resultaat van de extractie van vertaalbare tekstfragmenten uit het invoerdocument) en een vertaald document (met dezelfde structuur als het invoerdocument, maar waarin alle vertaalbare tekstfragmenten vervangen werden met inhoud uit het invoer-PO-bestand). Hier volgt een grafische voorstelling ervan:
Invoerdocument --\ /---> Uitvoerdocument
\ TransTractor:: / (vertaald)
+-->-- parse() --------+
/ \
Invoer-PO --------/ \---> Uitvoer-PO
(geëxtraheerd)
Dit kleine botje vormt de kern van de hele po4a-architectuur. Indien u de invoer-PO en het uitvoerdocument weglaat, krijgt u po4a-gettextize. Indien u de beide invoerdocumenten geeft en de uitvoer-PO negeert, krijgt u po4a-translate. De po4a aanroept tweemaal TransTractor en aanroept msgmerge -U tussen deze aanroepen van TransTractor in, om een totaaloplossing te bieden met één configuratiebestand. Raadpleeg Locale::Po4a::TransTractor(3pm) voor meer details.
Hier volgt een zeer gedeeltelijke lijst met projecten die po4a in productie gebruiken voor hun documentatie. Indien u wenst dat uw project wordt toegevoegd aan de lijst, stuur dan gewoon een e-mail (of een Merge Request).
Dit project voorziet in een infrastructuur voor het vertalen van veel man-pagina's naar verschillende talen, klaar om geïntegreerd te worden in verschillende belangrijke distributies (Arch Linux, Debian en derivativen, Fedora).
Zelf spreek ik het uit als pouah <https://en.wiktionary.org/wiki/pouah>, wat een Franse klanknabootsing is die men gebruikt voor bah :) Misschien heb ik een vreemd gevoel voor humor :)
Er zijn er een paar. Hier is een mogelijk onvolledige lijst, en er verschijnen meer hulpmiddelen aan de horizon.
Het kan enkel XML verwerken, en enkel een specifieke DTD. Ik ben erg ongelukkig met de verwerking van lijsten welke terechtkomen in één grote msgid. Wanneer de lijst groot wordt, is het moeilijker die brok door te slikken.
De belangrijkste voordelen van po4a tegenover hen zijn het gemak waarmee extra inhoud toegevoegd kan worden (wat bij deze andere hulpmiddelen nog moeilijker is) en de mogelijkheid een gettextize-procedure uit te voeren.
- https://docs.kde.org/stable5/en/kdesdk/lokalize/project-view.html
- http://www.debian.org/intl/l10n/
Maar niet alles is rozengeur en deze aanpak heeft ook enkele nadelen waarmee we moeten omgaan.
Een van mijn dromen is om po4a op een of andere manier te integreren in Gtranslator of Lokalize. Wanneer een documentatiebestand geopend wordt, zouden de tekstfragmenten automatisch geëxtraheerd worden en een vertaald bestand + po-bestand zouden naar schijf geschreven worden. Indien we erin zouden slagen een MS Word(TM)-module te ontwikkelen (of minstens een RTF-module), zouden zelfs professionele vertalers er gebruik van maken.
Denis Barbier <barbier,linuxfr.org> Martin Quinson (mquinson#debian.org)
| 2023-01-03 | Po4a-hulpmiddelen |