User:Charly Chevalier

Missions Principales
Analyze du fonctionnement de la localisation.

Ecriture d'un script de conversion .po en .sdf -> (Outil deja existant trouve).

Recherche de solution permettant l'utilisation directe d'un .po dans les sources.

Tests pour une locale.

Mise en oeuvre dans OOo4Kids.

Objectifs actuels

 * Reflexion sur : "Comment integrer les .po directement dans les sources".

[18-19]/08/2011
- Etudes des fichiers .sdf. Comprehension de la forme utilise pour trouver la traduction du mot demande, (lien avec fichier .src ou .ulf).
 * *.sdf -> [fichier donne dans le .sdf].{src/ulf} = traduction du mot dans la langue demande.
 * Identifiant unique donne a chaque "string" par le biais d'un define (ou autre representation), ce qui permet l'utilisation generique de ce dernier, dans le code. La traduction se basant sur cette identifiant, afin de trouver la traduction correcte. (Hypothese)

20/08/2011
Proposition de tâche pour aller plus loin dans la compréhension :

Dans les sources, le code est organisé de la façon suivante:

$nom_module/inc  -> contient les fichiers d'en-tête (définition interface) + .hrc $nom_module/source/rep_1 -> contient des fichier d'implémentation ( .cxx par exemple ) + quelques fichiers d'en-tête + .src $nom_module/source/rep_2 -> comme rep_1 $nom_module (autres)

Convention OpenOffice.org:


 * .hrc : fichier dans lequel on définit des constantes
 * .src : description type "vue" (dans le sens vue-modèle-controleur) -> on retrouve les constantes

Travail à faire: prendre un exemple, et retrouver le lien entre .sdf, .hrc, .src et l'utilisation dans un .cxx

Eric Bachard 09:28, 20 August 2011 (CEST)

21/08/2011
- path vers fichier .src (ou se trouve les constantes, ici elles ont aussi une valeur litterale. (dans la langue Anglaise/Americaine)). - nom de la constante correspondante au mot traduit (identique aux constantes utilisees dans le code). - langue dans laquelle le mot est traduit. - mot traduit dans la langue demandee.
 * Hypothese valide. Ce sont les constantes presentes dans les fichiers d'en-tete .hrc qui represente les differentes "strings" du programme.
 * Composition d'un fichier .sdf :

PS : Il reste des champs dont je n'ai pas encore saisie le sens.
 * Prochaine etape : Trouver le lien entre les .sdf et le code.

Indications:

Dans l10n :

Dans une boucle (pour chaque locale)


 * On part d'un fichier unique par locale nommé localize.sdf (dans OpenOffice.org), et qui contient tous les répertoires concernés, et les noms de fichiers .src concernés
 * On crée un fichier localize.sdf qui respecte l'arborescence correspondant aux .src existants

Exemple :

sur Mac OS X, on crée l10n/unxmacxi.pro/misc/sdf/desktop/source/app/localize.sdf

Important: TOUS les fichiers .src existant dans tous les modules sont donc traités => demande une grosse charge à la machine.

Dans desktop (plus tard)

Lorsque le module desktop sera compilé, pour chaque .src trouvé, on prendra la chaine trouvée dans un .src, et on ajoutera toutes les chaines correspondant aux locales contenues dans WITH_LANG ( si WITH_LANG=fr, on ajoutera fr). La référence utilisée sera donc le fichier créé dans desktop, et "délivré" dans le solver (endroit ou chaque module va chercher ce dont il a besoin pour être compilé.

En pratique, on aura dans desktop/source/app/, plusieurs fichiers .src, comme desktop.src. La chaine STR_RECOVER_TITLE est donnée en anglais (en-US par défaut) dans ce fichier, et on ajoutera les chaines traduites correspondant à WITH_LANG.

Soit avant :

String STR_RECOVER_TITLE {                                                                                                                               Text [ en-US ] = "File Recovery" ;

le fichier obtenu deviendra le nouveau fichier desktop.src:

Après :

String STR_RECOVER_TITLE {                                                                                                                               Text [ en-US ] = "File Recovery" ; Text [ fr ] = "Restauration de fichier" ; };

Enfin, on utilisera rsc (resource compiler) pour créer dek${locale}.res

Un fichier .res est un binaire correspondant à 1 seule locale, qui contient les chaines + une table donnant la position dans le binaire (l'offset).

On crée un fichier .res par locale, et pour créer un fichier .res, on concatène tous les fichiers .src utilisés dans la liste pour le module concerné. La liste exact des fichiers .src utilisés pour un module est donnée dans le makefile.mk.

Remarques (rapidement) : on doit donc compiler l10n avant tous les modules contenant des "vues" avec des chaines. Les dépendances de compilation sont définies dans $nom_module/prj/build.lst => première ligne == ce qui doit être compilé AVANT.

Eric Bachard 11:29, 22 August 2011 (CEST)

23/08/2011
Analyse et comprehension de ce qui est explique plus haut, en prenant des exemples dans les sources afin de mieux comprendre.
 * le lien des .sdf avec les modules et les .src est compris.
 * il me reste a voir plus en detail les .res.

25/08/2011
Etude des fichiers .res. (difficile de comprendre le binaire ;)). Reste a connaitre sa reele utilite. Est il utilise dans le code a proprement dit ? Servant alors de database ? Si non, il doit avoir une autre utilite, je m'y pencherais plus dessus des que possible.
 * Compte-rendu rapide du 23/08 a venir. (Conclusion personnelle tiree de mon analyse et ma comprehension du lien .sdf -> modules -> .src.).

26/08/2011
Compte-rendu sur les fichiers .sdf et des fichiers .src:
 * Les fichiers .src sont utilises dans le code. Ils sont (par defaut) en Anglais, mais selon la locale qu'on aimerait utiliser (cf WITH_LANG=.), ces derniers peuvent changer et donc se completer avec les traductions adaptees. Pour cela, ils se servent des fichiers .sdf qui contiennent les traductions des constantes utilises dans un module precis.
 * Il y a donc une transition (hors code) qui se fait entre les .src et les .sdf afin que les fichiers .src contiennent toutes les informations necessaires (traduction dans la locale voulue).
 * Ensuite, on se base donc sur les fichiers .src afin d'avoir les traductions des constantes utilisees dans le code.
 * Donc on utilise les fichiers .src dans le code. (J'aimerais le confirmer serieusement cette fois-ci, il faut d'abord que je comprenne l'utilite des .res afin de pouvoir le confirmer).

[27-28-29]/08/2011
Non disponible. (demenagement sur Paris). Je serais entierement disponible par la suite. (a partir du 30). Merci de votre comprehension.

31/08/2011
Analyse des fichiers .po.
 * Explication de la composition d'un fichier .po ici.
 * Etude du lien fichiers .po -> code. (exemples pris avec : ne_auth.c et fr.po).
 * Objectif du 01/09/2011 : Comprendre parfaitement ce lien.

01/09/2011
Etude plus approfondie des .po.: - Le header (l'entete) : il renseigne sur l'encodage, et d'autres types d'informations (e-mail, la langue, etc..).
 * Les fichiers .po se compose de 2 parties distinctes:

- Les strings de reference/a traduire : mgsid correspond aux strings non traduites (reference). mgstr corespond aux strings traduitent.

man setlocale man bindtextdomain man dgettext
 * Fonctions utilisees et necessaire afin de pouvoir utiliser les .po.

Il faut utiliser setlocale, afin de preciser ou se trouve les fichiers .mo (fichiers .po compiles) necessaires a la traduction de la string (mgsid) dans le code. En utilisant bindtextdomain, on informe le domaine que l'on va utiliser. La fonction dgettext prend en parametre le nom du domaine et une string (mgsid), cette string a pour but d'etre la string par defaut (dans la langue par defaut donc), mais surtout elle a pour but d'etre une reference. En effet, grace a cette reference, dgettext va pouvoir chercher dans le domaine donne, et donc remplacer cette reference par la traduction souhaitee.

Le fichier .po utilise, comporte : mgsid "Salut" mgstr "Hi" Resultat du programme avec pour valeur en mgsid : "Salut" (parametre de la fonction dgettext): $> ./a.out Hi $>
 * Code present ici.

- PoEdit
 * Outils utilises pour editer et verifier la validite d'un fichier .po:

- msgfmt -c *.po

[05-06]/09/2011
Lecture de quelques tutoriaux sur le langage Python afin de (si necessaire) ecrire un script de conversion .sdf -> .po.

Decouverte de l'outil oo2po qui permet de convertir un fichier .sdf en .po. Documentation ici. J'ai reussi a le faire fonctionner. Je vais expliquer plus en detail comment cet outil procede.

Synopsis: oo2po [OPTIONS - FLAGS] [FILE] [DIRECTORY DESTINATION]

Afin de transformer un .sdf en .po, deux flags vont nous etres utiles: Il sert en fait a donner la langue dans laquelle on souhaite traduire. (valeur de msgstr dans les .po). Il sert a donner la langue de la langue source (la string reference). (par defaut en en-US, donc en anglais/americain, actuellement ce qui est utilise comme reference dans OOo4kids). (valeur de msgid dans les .po).
 * -l [LANG] ou --language [LANG]
 * --source-language [LANG]

Voici un exemple (pour une traduction en francais): On utilise un fichier .sdf comme celui-ci: dir    stringtest.src  0       string  TEST                            0       fr      Salut dir    stringtest.src  0       string  TEST                            0       en-US   Hi Ensuite, on tape la commande suivante : oo2po -l fr localize.sdf result J'obtiens donc un fichier .po comme ceci (il se trouve dans le dossier result et porte le nom dir.po). msgid "" msgstr "" "Project-Id-Version: PACKAGE VERSION\n" "Report-Msgid-Bugs-To: http://qa.openoffice.org/issues/enter_bug.cgi?subcompo" "nent=ui&comment=&short_desc=Localization%20issue%20in%20file%3A%" "20dir.oo&component=l10n&form_name=enter_issue\n" "POT-Creation-Date: 2011-09-06 14:33+0200\n" "PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n" "Last-Translator: FULL NAME \n" "Language-Team: LANGUAGE \n" "Language: fr\n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=UTF-8\n" "Content-Transfer-Encoding: 8bit\n" "X-Generator: Translate Toolkit 1.7.0\n" "X-Accelerator-Marker: ~\n"
 * 1) . extracted from dir.oo

msgid "Hi" msgstr "Salut"
 * stringtest.src#TEST.string.text

Voila comment obtenir un fichier .po a partir d'un fichier .sdf via l'outil oo2po.

07/09/2011
Etudes de resource compiler (rsc), afin de voir si il est possible d'obtenir les .res via les .po.

Objectifs des jours a venir :
 * Comprendre son utilitee pour tout types de fichiers.
 * Analyser le source-code afin de voir si il est possible de passer directement par les .po afin d'obtenir les .res.
 * Implementer la modification du traitement des .po a la place des .sdf dans le code.

08/09/2011
Installation de OpenGrok afin de pouvoir l'utiliser et ainsi, mieux parcourir les sources de rsc (Resource Compiler). Tutorial.

12/09/2011
J'ai reussi a faire fonctionner rsc (pas entierement, mais je peux tout de meme 'tenter' de compiler des .src par exemple).

Je vais tenter de le faire fonctionner parfaitement en me basant sur des .src pour avoir des .res. (dans les jours a venir).

Une fois que cela sera fait, je tenterais de pouvoir le compiler independamment des autres modules. Comme ca je pourrais y ajouter du code (printf etc..) et ainsi mieux cerner le mechanisme utilise.

13/09/2011
J'ai peut-etre enfin reussi a compiler seul le "module" rsc. Je continue dans ma lancee, demain. (Il me faut une version saine de OOo4kids, ma version actuelle ne me permet pas de pouvoir build independamment les modules des uns des autres. Cependant j'ai reussi a build rsc seul avec la version de dobat_f (sur sa machine). Je verrais donc demain, pour que je puisse moi-meme, mettre en oeuvre ceci, dans une nouvelle version).

14/09/2011
J'ai reussi a compiler rsc seul. cd [dossier ou se trouve les sources (par defaut: trunk)] ./configure --disable-gtk --disable-odk --disable-gnome-vfs --with-lang=fr ./bootstrap source LinuxX86Env.Set.sh
 * Pour le compiler, il faut configurer l'environnement comme si nous allions build tout le projet. (Il faut build le projet au moins une fois afin de pouvoir le compiler seul).
 * 1) ce sont les options que j'utilise, il n'est pas necessairement obligatoire de mettre les memes que moi.

cd rsc build
 * L'environnement est maintenant pret. On peut donc build le 'module' rsc.
 * La compilation est en cours.

A present je peux me lancer dans le code en y laissant des marqueurs (beaucoup plus facile pour la comprehension).

[15-16]/09/11

 * Etudes du source-code. (actuellement dans le parser (= parser Bison)).
 * Je n'ai toujours pas reussi a faire fonctionner le binaire correctement. (malgre diverses tentatives, il semblerait que les fichiers passes en parametres comporte toujours des erreurs syntaxiques. Je tente de voir dans le code (parser) ou se trouverait le probleme lie aux fichiers que j'utilise.)

[19-20]/09/11

 * Comprehension de l'utilisation des binaires (je n'ai toujours pas vraiment reussi a les faire fonctionner, mais j'ai compris deux etapes importantes):

Le binaire rsc, lance va se servir de deux autres binaires: - premierement il va se servir de rscpp qui signigie: resource compiler preprocesseur. Ce binaire doit etre une etape intermediaire avant la compilation d'un fichier. Il doit remplacer chaque identifiants par une certaine valeur afin qu'elle puisse etre interpreter par la suite. - puis, rsc va se servir de rsc2 qui lui va traiter les fichiers passes dans rscppp, pour ensuite les compiler.

Ce sont grossierement les etapes qui permettent (par exemple), d'obtenir des .res via des fichiers .src. Ce qu'il faut retenir c'est qu'il y a deux etapes fondamentales:
 * le preprocesseur : prepare les fichiers pour leur traitement (la compilation).
 * la compilation : va parser et interpreter les nouveaux fichiers afin de pouvoir les compiler (et donc les rendre sous forme binaire, comme les .res).

21/09/11
Correction de probleme suite a des erreurs de compilation de OOo4kids (nouvelle version telechargee). Cette compilation va me permettre d'avoir un fichier de log afin de comprendre comment, et ou est utilise rsc.

22/09/11
Fichier de log obtenu. En l'explorant j'ai pu decouvrir un autre binaire portant sur rsc.

Son nom : rscdep:
 * J'imagine qu'il doit (avant toute "compilation" d'un fichier) rechercher les dependances declarer dans les fichiers a compiler. (par exemples des headers ou autres).
 * C'est ce binaire qui est utilise lors de la compilation totale du sujet.

Il doit donc y avoir plusieurs etapes afin de pouvoir obtenir (par exemple) un .res via un .src
 * rscdep : va fournir les dependances
 * rsc : qui va lancer deux autres binaires
 * rscpp : lance le preprocesseur et va donc permettre de transformer chaque identifiants par une certaines valeurs afin que le nouveau fichier soit "compilable" par rsc2.
 * rsc2 : va compiler le fichier. (le nouveau fichier cree temporairement: (ca permet de garder le fichier de base et de passer par un fichier de transition)).

On a donc dans l'ordre:

rscdep -> rsc (qui va lancer deux autres binaires) -> rscpp -> rsc2

PS : Ceci ne sont que des suppositions. Cependant, je peux (presque) confirmer que dans la pratique, c'est ce qui se passe afin de compiler un fichier (par exemple) .src.

23/09/11
Recherche dans le code, de ma decouverte du 22/09. J'ai utilise rscdep sur un fichier .src, le fichier ressorti ne me donne pas beaucoup d'information.


 * Peut-etre ai-je mal compris l'utilite de ce binaire ?


 * Peut-etre qu'il n'a aucun lien avec rsc ( et donc rscpp et rsc2) ?

Pour cela, il va falloir que je me replonge dans le code pour comprendre.. Cependant, un probleme persiste toujours, celui de ne pas reussir a faire fonctionner rsc sur un fichier .src. Je continue mes recherches pour en comprendre mieux le fonctionnement.

Fichier actuellement etudie : ./source/prj/start.cxx

[26-27]/09/11
Toujours en etude du code du module rsc. (avance dans la recherche de comment faire fonctionner rsc, je n'arrivais pas a le faire fonctionner car il faut faire des commandes hors code. Comme copier-coller le binaire rsc2 dans "/").

Cependant, aucune trace de rscdep dans le code.

Fichier actuellement etudie : ./source/prj/start.cxx

28/09/11
Reussir a compiler des fichiers via le binaire rsc.

J'arrive a obtenir des fichiers via le binaire rsc.

Cependant, ce sont des fichiers qui ont pour extensions: .rc et ilst. Ce sont eux aussi des binaires (les .rc, les ilst sont vides), et semblent etre identiques aux fichiers .res.

Ma prochaine etape sera de trouver le lien entre les .rc et les .res. Peut-etre que les .res sont a la base nommes en .rc puis renomme en .res par la suite ? Je dois trouver ce lien.

Fichier actuellement etudie : ./source/prj/start.cxx

30/09/11
./rsc -s [file].src Cette commande va donc creer un fichier avec l'extension suivante : .srs.
 * Je viens de decouvrir un flag qui permettait d'obtenir d'autres types de fichiers que des .rc.
 * 1) Il faut premierement coller rsc2 et rscpp dans le dossier suivant : "/". (pour permettre au binaire rsc de fonctionner).

Selon l'aide du binaire, il faut ensuite executer le binaire avec -l afin de linker les fichiers crees par cette commande et donc obtenir des fichiers .res

Je n'ai pas encore reussi a obtenir de .res, mais je continue a explorer le code afin de savoir ou est-ce que je fais une erreur.


 * Installation de Debian. (je travaille actuellement sur Ubuntu).

Il est donc possible que je travaille sur Debian tres prochainement.

Fichier actuellement etudie : ./source/prj/start.cxx

[03-04]/10/11

 * Toujours dans l'exploration du code. (soucis rencontre: je ne connais pas le contenu de la classe ByteString)
 * En consequence: ecriture d'un script qui permet grep un pattern selon un fichier contenant le noms des differents includes d'un fichier source.
 * 1) ! /bin/sh

while read line do for file in `locate $line` do echo "$file\n" grep -Rn "$2" $file done done < $1

Cet outil me servira pour toutes les classes dont je ne sais pas me servir afin de pouvoir continuer mon exploration du code.

PS : je cherche toujours le moyen d'obtenir des fichiers .res afin de voir comment ces derniers sont crees (parse et compile, directement dans le code).

Fichier actuellement etudie : ./source/prj/start.cxx

05/10/11
Exploration du source-code qui constitue le binaire rsc2. (rscpp etant la partie preprocesseur, cette derniere va s'occuper de transformer les ids en autres ids pour qu'ils soient comprehensible pour la compilation / pour rsc2).

Fichier actuellement etudie : ./source/rsc/rsc.cxx