Discussion :

[ThWilliam]

Bonjour à tous.

Je viens de Delphi et je suis en train de convertir mes codes.
J'ai découvert un sacré problème concernant le traitement des strings (j'ai vu que je n'étais pas le seul, cfr un message précédent sur ce forum) en tentant de compiler une fonction de remplacement des caractères accentués.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
 
function SU_RemoveAccents(const S: string): string;
var
  Ch: Char;
  L: Integer;
  Source, Dest: PChar;
begin
  L := Length(S);
  SetLength(Result, L);
  Source := Pointer(S);
  Dest := Pointer(Result);
  while L <> 0 do
  begin
    Ch := Source^;
    case Ch of
      'á', 'à', 'â', 'ä' : Ch:= 'a';
      // ...
    end;
    Dest^ := Ch;
    Inc(Source);
    Inc(Dest);
    Dec(L);
  end;
end;

Lazarus utilise le Utf8.
Les fonctions de chaines pourtant baptisées "Ansi..." marchent bien mais problèmes lors d'un traitement caractère par caractère.

S:= 'élèves'
Length(S) --> 8
P:= Pos('è', S) --> 4
S2:= Copy(S, P+1, Length(S) --> évidemment ne marche plus puisque les caractères accentués prennent 2 octets.

Transformer S en chaine Ansi ne m'aide pas. La longueur retombe à 6, mais je n'ai plus les caractères accentués.

Après des heures de recherche, je vois enfin un site (http://www.marclebrun.be/wiki/doku.p...mes_rencontres) qui me donne la solution : travailler en fichier source Ansi (il fallait y penser !).
C'est Ok, mais comme les propriétés strings de composants sont en Utf8, cela m'oblige à faire :

S:= Utf8ToAnsi(edit1.text);

Voyez-vous une autre solution que d'encoder en Ansi ?
Autrement dit, comment savoir si un caractère occupe 1 octet ou plus.

Merci d'avance.
Cordialement
Thierry

[tourlourou]

sous Windows, une solution Delphi proposée par Andnotor

[Jipété]

Mais pourquoi vouloir supprimer ces accents (cette question revient de temps en temps ici ou là...) alors qu'ils ont pleine valeur orthographique dixit l'Académie française (ce qui sous-entend qu'il les faut également sur les majuscules).

J'ai connu quelqu'un qui a eu des soucis administratifs car certains de ses papiers officiels avaient été orthographiés sans accent là où à l'origine il y en avait !

[ThWilliam]

@tourlourou : rien trouvé sur le site que tu mentionnes.

@jipété : tu m'as mal compris. La fonction pour remplacer les accents n'était qu'un exemple. Ma question est en fait : puisque dans un string il peut y avoir des caractères à nombre d'octets variable, comment fait-on pour travailler caractère par caractère ?
Je n'ai rien contre les accents et je respecte l'orthographe
Mais, dans une recherche de mots, pour comparer 2 chaines "élève" et "eleve" , il faut bien remplacer les accents ! Je ne connais pas de fonction toute faite qui permette cela, sauf la fonction Windows "Comparestring".

Cordialement
Thierry

[DomDA91]

Bonjour...

Voyez-vous une autre solution que d'encoder en Ansi ?
Autrement dit, comment savoir si un caractère occupe 1 octet ou plus.

Si pour des application paticulières on veut travailler au niveau des caractères, en UTF8 c'est relativement facile :

• Tout octet inférieur à 128 ($0..$7F) est un caractère ASCII (7 bits) standard.
• Tout octet de 128 à 253 ($80..$FD) fait partie d'une séquence caractère multi-octets
• Les codes 254 et 255 ($FE, $FF) sont interdits.

Tout code de l'intervalle $C0..$FD est le premier octet d'une séquence et indique le nombre d'octets complémentaires qui suivent :
$C0..$DF : 1 octet complémentaire (5 bits faibles ignorés)
$E0..$EF : 2 octets complémentaires (4 bits faibles ignorés)
$F0..$F7 : 3 octets complémentaires (3 bits faibles ignorés)
$F8..$FB : 4 octets complémentaires (2 bits faibles ignorés)
$FC..$FD : 5 octets complémentaires (1 bit faible ignoré)

Tout code de l'intervalle $80..$BF représentent les octets complémentaires d'une séquence.

Les bits ignorés du premier octet juxtaposés aux 6 bits faibles de chacun des octets complémentaires de la séquence représentent la valeur du point de code UNICODE. Le bit le plus faible du dernier octet complémentaire étant cadré sur le bit faible du point de code.

Dans la pratique les séquences de 5 ou 6 octets ne se rencontrent pas car elles correspondent à des valeur de point de code situées au delà de la limite fixée par UNICODE et ISO 10648 (actuellement U+10FFFF).

Les séquences jusqu'à 3 octets permettent de couvrir la totalité du PMB (Plan Multilingue de Base) UNICODE.

Par exemple pour compter le nombre de caractères d'une chaîne UTF8 il suffit de compter les octets en excluant les octets complémentaires, càd les valeurs comprises dans l'intervalle $80..$BF (je n'ai pas vérifié mais il y a peut-être une fonction de la LCL qui fait cela).

Pour ce qui est de ton problème, la plupart des lettres accentuées du français sont des séquences de deux octets commençant par un premier octet $C3 suivi d'un octet complémentaire $A? ou $B?.

[tourlourou]

Pardon pour le lien : http://www.developpez.net/forums/d69...s/#post4047918

[ThWilliam]

@ tourlourou : merci pour le lien et bonne soirée.

Bonsoir Dom...

Superbe explication
Et je viens de faire un test, les accents ont bien le premier octet à $C3, le deuxième octet va de $80 (majuscules accentuées) à $BF.

Un grand merci.

Cordialement
Thierry