projman/hlp/fr/tcl/binary.htm

179 lines
24 KiB
HTML
Raw Normal View History

2015-10-19 13:27:31 +03:00
<HTML><HEAD>
<BASEFONT FACE="Times New Roman" SIZE="2" COLOR="#000000">
</HEAD>
<BODY>
<div><H3><b>binary&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Commandes Internes Tcl</b></H3></div>
<HR ALIGN="center">
<div><b>NOM</b></div> <br>
<div ALIGN="LEFT" style="margin-left: 51px;">binary - Ins<6E>re et extrait des champs <20> partir de cha<68>nes binaires
</div><br>
<div><b>SYNTAXE</b></div><br>
<div ALIGN="LEFT" style="margin-left: 51px;"><b>binary format </b><i>formatString </i>?<i>arg arg ...</i>? <br>
<b>binary scan </b><i>string formatString </i>?<i>varName varName ...</i>?
</div><br>
<div><b>DESCRIPTION</b></div><br>
<div ALIGN="LEFT" style="margin-left: 51px;">Cette commande fournit des facilit<69>s pour la manipulation de donn<6E>es binaires. La premi<6D>re forme, <b>binary format</b>, cr<63>e une cha<68>ne binaire <20> partir de valeurs Tcl standards. Par exemple, en partant des valeurs 16 et 22, elle produira une cha<68>ne binaire de 8 octets constitu<74>e de deux entiers de 4 octets, un pour chacun des nombres. La seconde forme de la commande, <b>binary scan</b>, fait le contraire: elle extrait les donn<6E>es <20> partir d'une cha<68>ne binaire et les renvoie comme des valeur cha<68>nes Tcl ordinaire.
</div><br>
<div><b>BINARY FORMAT</b></div><br>
<div ALIGN="LEFT" style="margin-left: 51px;">La commande <b>binary format</b> g<>n<EFBFBD>re une cha<68>ne binaire dont le format est sp<73>cifi<66> par le <i>formatString</i> et dont le contenu provient des arguments suppl<70>mentaires.&nbsp; La valeur binaire r<>sultante est renvoy<6F>e. </div>
<div ALIGN="LEFT" style="margin-left: 51px;">Le <i>formatString</i> est constitu<74> d'une s<>quence de z<>ro ou plus de sp<73>cificateurs de champs s<>par<61>s par z<>ro ou plusieurs espaces. Chaque sp<73>cificateur de champ est un simple caract<63>re suivi par un nombre optionnel <i>compte</i>. La plupart des sp<73>cificateurs de champs attendent un argument pour formater la valeur. Le caract<63>re sp<73>cifie comment la valeur est format<61>e. Le nombre <i>compte</i> indique combien d'items du type sp<73>cifi<66> sont pr<70>sents dans la valeur. Si pr<70>sent, <i>compte</i> est un entier d<>cimal non-n<>gatif ou <A HREF="24.htm"><b>*</b></A>, qui indique normalement que tous les <20>l<EFBFBD>ments de la valeur doivent <20>tre utilis<69>s. Si le nombre d'arguments ne correspond&nbsp; pas au nombre de champs dans le format cha<68>ne qui attend les arguments, alors une erreur est g<>n<EFBFBD>r<EFBFBD>e. </div>
<div ALIGN="LEFT" style="margin-left: 51px;">Chaque paire type-compte d<>place un curseur imaginaire au travers des donn<6E>es binaires, en stockant les octets <20> la position courante et avancant le curseur juste apr<70>s le dernier octet stock<63>.&nbsp; Le curseur est initialement <20> la position 0 au d<>but des donn<6E>es. Le type peut <20>tre l'un des caract<63>res suivants: </div>
<div ALIGN="LEFT" style="margin-left: 51px;">
<DL>
<DT><b>a</b></DT><DD>Stocke une cha<68>ne de caract<63>res de longueur <i>compte</i> dans la cha<68>ne de sortie. Si <i>arg</i> a moins d'octets que <i>compte</i>, alors des octets suppl<70>mentaire nuls sont utilis<69>s pour remplir le champ. Si <i>arg</i> est plus long que la longueur sp<73>cifi<66>e, les caract<63>res suppl<70>mentaires sont ignor<6F>s. Si <i>compte</i> est <b>*</b></A>, alors tous les octets de <i>arg</i> sont format<61>s. Si <i>compte</i> est omis, alors un caract<63>re est format<61>. Par exemple,
<b>binary format a7a* alpha bravo charlie</b>
renverra une cha<68>ne <20>quivalente <20> <b>alpha&#92;000&#92;000bravoc</b>.
</DD>
<DT><b>A</b></DT><DD>Cette forme est la m<>me que <b>a</b> except<70> que des espaces sont utilis<69>s pour le remplissage au lieu de nuls. Par exemple,
<b>binary format A6A*A alpha bravo charlie</b>
renverra <b>alpha bravoc</b>.
</DD>
<DT><b>b</b></DT><DD>Stocke une cha<68>ne de <i>compte</i> chiffres binaires en ordre croissant dans chaque octet de la cha<68>ne de sortie. <i>Arg</i> doit contenir une s<>quence de <b>1</b> et de <b>0</b>. Les octets r<>sultants sont emis du premier au dernier&nbsp; avec les bits format<61>s de bas en haut dans chaque octet. Si <i>arg</i> a moins de chiffres que <i>compte</i>, alors des z<>ros seront utilis<69>s pour les bits restant. Si <i>arg</i> a plus de chiffres que le nombre sp<73>cifi<66>s, les chiffres suppl<70>mentaires sont ignor<6F>s.&nbsp; Si <i>compte</i> est <b>*</b></A>, alors tous les chiffres de <i>arg</i> sont format<61>s. Si <i>compte</i> est omis, alors un digit est format<61>. Si le nombre de bits format<61>s ne finit pas <20> un&nbsp; une limite d'octet, les bits restants du dernier octet seront des z<>ros. Par exemple,
<b>binary format b5b* 11100 111000011010</b>
renverra une cha<68>ne <20>quivalentee <20> <b>&#92;x07&#92;x87&#92;x05</b>.</DD>
<DT><b>B</b></DT><DD>Cette forme est la m<>me que <b>b</b> except<70> que le bits sont stock<63>s dans l'ordre descendant dans chaque octet. Par exemple,
<b>binary format B5B* 11100 111000011010</b>
renverra une cha<68>ne <20>quivalentee <20> <b>&#92;xe0&#92;xe1&#92;xa0</b>.
</DD>
<DT><b>h</b></DT><DD>Stocke une cha<68>ne de <i>compte</i> chiffres hexad<61>cimaux de bas en haut dans chaque octet de la cha<68>ne de sortie.&nbsp; <i>Arg</i> doit contenir une s<>quence de caract<63>res comprise dans ``0123456789abcdefABCDEF''. Les octets r<>sultants sont <20>mis du premier au dernier avec les chiffres hexa format<61>s de bas en haut dans chaque octet.&nbsp; Si <i>arg</i> a moins de chiffres que <i>compte</i>, alors des z<>ros sont utilis<69>s pour les chiffres restants. Si <i>arg</i> a plus de chiffres que le nombre sp<73>cifi<66>s, les chiffres suppl<70>mentaires seront ignor<6F>s.&nbsp; Si <i>compte</i> est <b>*</b>, alors tous les chiffres de <i>arg</i> seront format<61>s.&nbsp; Si <i>compte</i> est omis, alors un digit est format<61>.&nbsp; Si le nombre de chiffres format<61>e ne finit pas <20> une limite d'octet, les bits restants du dernier octet seront des z<>ros. Par exemple,
<b>binary format h3h* AB def</b>
renverra une cha<68>ne <20>quivalente <20> <b>&#92;xba&#92;x00&#92;xed&#92;x0f</b>.
</DD>
<DT><b>H</b></DT><DD>Cette forme est la m<>me que <b>h</b> except<70> que le chiffres sont stock<63>s de&nbsp; haut en bas dans chaque octet.&nbsp; Par exemple,
<b>binary format H3H* ab DEF</b>
renverra une cha<68>ne <20>quivalente <20> <b>&#92;xab&#92;x00&#92;xde&#92;xf0</b>.
</DD>
<DT><b>c</b></DT><DD>Stocke une ou plusieurs valeur enti<74>res 8-bit dans la cha<68>ne de sortie.&nbsp; Si aucun <i>compte</i> n'est sp<73>cifi<66>, alors <i>arg</i> doit <20>tre une valeur enti<74>re; autrement <i>arg</i> doit <20>tre une liste contenant au moins <i>compte</i> <20>l<EFBFBD>ments entiers.&nbsp; Les 8 bits de poids faible de chaque entier sont stock<63>s comme une valeur d'un octet <20> la position du curseur.&nbsp; Si <i>compte</i> est <b>*</b>, alors tous les entiers de la liste sont format<61>s.&nbsp; Si le nombre d'<27>l<EFBFBD>ments dans la liste est inf<6E>rieur <20> <i>compte</i>, alors une erreur est g<>n<EFBFBD>r<EFBFBD>e.&nbsp; Si le nombre d'<27>l<EFBFBD>ments dans la liste est sup<75>rieur <20> <i>compte</i>, alors les <20>l<EFBFBD>ments suppl<70>mentaires sont ignor<6F>s.&nbsp; Par exemple,
<b>binary format c3cc* &#123;3 -3 128 1} 260 &#123;2 5}</b>
renverra une cha<68>ne <20>quivalente <20> <b>&#92;x03&#92;xfd&#92;x80&#92;x04&#92;x02&#92;x05</b>, alors que
<b>binary format c &#123;2 5}</b>
g<EFBFBD>n<EFBFBD>rera une erreur.
</DD>
<DT><b>s</b></DT><DD>Cette forme est la m<>me que <b>c</b> except<70> qu'elle stocke un ou plusieurs entiers 16-bit en ordre little-endian dans la cha<68>ne de sortie. Les 16 bits de poids faible de chaque entier sont stock<63>s comme une valeur de deux-octet <20> la position du curseur avec l'octet de poids faible stock<63> en premier.&nbsp; Par exemple,
<b>binary format s3 &#123;3 -3 258 1}</b>
renverra une cha<68>ne <20>quivalente <20>&nbsp; <b>&#92;x03&#92;x00&#92;xfd&#92;xff&#92;x02&#92;x01</b>.
</DD>
<DT><b>S</b></DT><DD>Cette forme est la m<>me que <b>s</b> except<70> qu'elle stocke un ou plusieurs entiers 16-bit en ordre big-endianx dans la cha<68>ne de sortie.&nbsp; Par exemple,
<b>binary format S3 &#123;3 -3 258 1}</b>
renverra une cha<68>ne <20>quivalente <20>&nbsp; <b>&#92;x00&#92;x03&#92;xff&#92;xfd&#92;x01&#92;x02</b>.
</DD>
<DT><b>i</b></DT><DD>Cette forme est la m<>me que <b>c</b> except<70> qu'elle stocke un ou plusieurs entiers 32-bit en ordre little-endian dans la cha<68>ne de sortie. Les 32 bits de poids faible de chaque entier sont stock<63>s comme une valeur de quatre-octet <20> la position du curseur avec l'octet de poids faible stock<63> en premier.Par exemple,
<b>binary format i3 &#123;3 -3 65536 1}</b>
renverra une cha<68>ne <20>quivalente <20> <b>&#92;x03&#92;x00&#92;x00&#92;x00&#92;xfd&#92;xff&#92;xff&#92;xff&#92;x00&#92;x00&#92;x01&#92;x00</b>
</DD>
<DT><b>I</b></DT><DD>Cette forme est la m<>me que <b>i</b> except<70> qu'elle stocke un ou plusieurs 32-bit entiers en ordre big-endian dans la cha<68>ne de sortie. Par exemple,
<b>binary format I3 &#123;3 -3 65536 1}</b>
renverra une cha<68>ne <20>quivalente <20> <b>&#92;x00&#92;x00&#92;x00&#92;x03&#92;xff&#92;xff&#92;xff&#92;xfd&#92;x00&#92;x01&#92;x00&#92;x00</b>
</DD>
<DT><b>f</b></DT><DD>Cette forme est la m<>me que <b>c</b> except<70> qu'elle stocke un ou plusieurs flottants simple precision dans la repr<70>sentation native de la machine dans la cha<68>ne de sortie. Cette repr<70>sentation n'est pas portable, donc elle ne doit pas <20>tre utilis<69>e pour communiquer des nombres flottants sur le r<>seau. La taille d'un nombre flottant peut varier selon les architectures, donc le nombre d'octets g<>n<EFBFBD>r<EFBFBD>s peut varier.Si la valeur deborde de la repr<70>sentation native de la machine, alors la valeur de FLT_MAX d<>finie par le syst<73>me sera utilis<69>e.Parce que Tcl utilise des nombres flottants double-precision en interne, il peut y avoir une certaine perte de precision dans la conversion en simple-precision. Par exemple, sur un syst<73>me Windows s'ex<65>cutant sur un processeur Pentium Intel,
<b>binary format f2 &#123;1.6 3.4}</b>
renverra une cha<68>ne <20>quivalente <20><b>&#92;xcd&#92;xcc&#92;xcc&#92;x3f&#92;x9a&#92;x99&#92;x59&#92;x40</b>.
</DD>
<DT><b>d</b></DT><DD>Cette forme est la m<>me que <b>f</b> except<70> qu'elle stocke un ou plusieurs flottants double-precision dans la repr<70>sentation native de la machine dans la cha<68>ne de sortie.&nbsp; Par exemple, sur un syst<73>me Windows s'ex<65>cutant sur un processeur Pentium Intel,
<b>binary format d1 &#123;1.6}</b>
renverra une cha<68>ne <20>quivalente <20> <b>&#92;x9a&#92;x99&#92;x99&#92;x99&#92;x99&#92;x99&#92;xf9&#92;x3f</b>.
</DD>
<DT><b>x</b></DT><DD>Stocke <i>compte</i> octet nuls dans la cha<68>ne de sortie. Si <i>compte</i> n'est pas sp<73>cifi<66>, elle stocke un octet null.&nbsp; Si <i>compte</i> est <b>*</b>, elle g<>n<EFBFBD>re une erreur. Ce type n'attend pas d'argument.Par exemple,
<b>binary format a3xa3x2a3 abc def ghi</b>
renverra une cha<68>ne <20>quivalente <20> <b>abc&#92;000def&#92;000&#92;000ghi</b>.
</DD>
<DT><b>X</b></DT><DD>D<EFBFBD>place le curseur en arri<72>re de <i>compte</i> octets dans la cha<68>ne de sortie.&nbsp; Si <i>compte</i> est <b>*</b>ou est sup<75>rieur <20> la position courante du curseur, alors le curseur est positionn<6E> <20> l'emplacement 0 ainsi l'octet suivant stock<63> sera le premier octet dans la cha<68>ne r<>sultat. Si <i>compte</i> est omis alors le curseur est d<>plac<61> d'un octet vers l'arri<72>re. Ce type n'attend pas d'argument.Par exemple,
<b>binary format a3X*a3X2a3 abc def ghi</b>
renverra <b>dghi</b>.
</DD>
<DT><b>@</b></DT><DD>D<EFBFBD>place le curseur <20> l'emplacement absolu sp<73>cifi<66> par <i>compte</i> dans la cha<68>ne de sortie.&nbsp; La position 0 correspond au premier octet dans la cha<68>ne de sortie.&nbsp; Si <i>compte</i> correspond <20>&nbsp; une position au-dela du dernier octet stock<63>, alors des octet nuls seront&nbsp; plac<61>s aux emplacements non initalis<69>s et le curseur sera plac<61> <20> l'emplacement sp<73>cifi<66>.&nbsp; Si <i>compte</i> est <b>*</b>, alors le curseur est d<>plac<61> <20> la fin de la cha<68>ne de sortie actuelle.&nbsp; Si <i>compte</i> est omis, alors une erreur est g<>n<EFBFBD>r<EFBFBD>e. Ce type n'attend pas d'argument. Par exemple,
<b>binary format a5@2a1@*a3@10a1 abcde f ghi j</b>
renverra <b>abfdeghi&#92;000&#92;000j</b>. <br>
</DD>
</DL>
</div>
<div><b>BINARY SCAN</b></div><br>
<div ALIGN="LEFT" style="margin-left: 51px;">La commande <b>binary scan</b> analyse les champs d'une cha<68>ne binaire, retournant le nombre de conversions effectu<74>es.&nbsp; <i>String</i> donne l'entr<74>e <20> analyser et <i>formatString</i> indique comment l'analyser. Chaque <i>varName</i> donne le nom d'une variable; quand un champ de <i>string</i> est analys<79> le r<>sultat est assign<67> <20> la variable correspondante. </div>
<div ALIGN="LEFT" style="margin-left: 51px;">Comme avec <b>binary format</b>, le <i>formatString</i> est constitu<74> d'une s<>quence de z<>ro ou plusieurs sp<73>cificateurs de champs s<>par<61>es par z<>ro ou plusieurs espaces.&nbsp; Chaque sp<73>cificateur de champ est un simple caract<63>re suivi par un nombre optionnel <i>compte</i>.&nbsp; La plupart des sp<73>cificateurs de champs utilisent un argument pour obtenir la variable dans laquelle les valeurs seront plac<61>es.&nbsp; Le caract<63>re sp<73>cifie comment les donn<6E>es binaires sont interpr<70>t<EFBFBD>es.&nbsp; Le <i>compte</i> indique typiquement combien d'examplaires du type sp<73>cifi<66> sont extraits des donn<6E>es.&nbsp; Si pr<70>sent, <i>compte</i> est un entier d<>cimal non-n<>gatif ou <b>*</b>, qui indique normalement que tous les items restant dans les donn<6E>es doivent <20>tre utilis<69>s. S'il n'y a pas assez d'octets apr<70>s la position courante du curseur pour satisfaire le sp<73>cificateur de champ courant, alors la variable correspondante est inchang<6E>e et <b>binary scan</b> retourne imm<6D>diatement avec le nombre de variables qui ont <20>t<EFBFBD> de'finies. S'il n'y a pas assez d'arguments pour tous les champs de la cha<68>ne format n<>cessitant des arguments, alors une erreur est g<>n<EFBFBD>r<EFBFBD>e. </div>
<div ALIGN="LEFT" style="margin-left: 51px;">Il est <b>important</b> de noter que les <b>c</b>, <b>s</b>, et <b>S</b> (et <b>i</b> et <b>I</b> sur les syst<73>mes 64bit) extraient les donn<6E>es dans des entiers de type long.&nbsp; Ce faisant, les entiers qui ont leurs bit haut&nbsp; positionn<6E> (0x80 pour chars, 0x8000 pour shorts, 0x80000000 pour ints), seront sign<67>es.Ainsi : </div>
<div ALIGN="LEFT" style="margin-left: 102px;"><b>set signShort &#91;binary format s1 0x8000]</b><br>
<b>binary scan &#36;signShort s1 val;</b><i># val == 0xFFFF8000</i></div>
<div ALIGN="LEFT" style="margin-left: 51px;">Si vous voulez produire une valeur non sign<67>e, vous pouvez masquer la valeur de retour <20> la taille d<>sir<69>e.&nbsp; Par exemple, pour produire un entier court non sign<67>e: </div>
<div ALIGN="LEFT" style="margin-left: 102px;"><b>set val &#91;expr &#123;&#36;val &amp; 0xFFFF}];</b><i># val == 0x8000</i></div>
<div ALIGN="LEFT" style="margin-left: 51px;">Chaque paire type-compte d<>place un curseur imaginaire le long des donn<6E>es binaires, en lisant les octets <20> la position courante.&nbsp; Initialement le curseur est <20> la position 0 au d<>but des donn<6E>es. Le type peut <20>tre l'un des caract<63>res suivants:
<DL>
<DT><b>a</b></DT><DD>Les donn<6E>es sont une cha<68>ne de caract<63>res de longueur <i>compte</i>.&nbsp; Si <i>compte</i> est <b>*</b>, alors tous les octets restants dans <i>string</i> seront scann<6E>s dans la variable.&nbsp; Si <i>compte</i> est omis, alors un caract<63>re sera scann<6E>. Par exemple,
<b>binary scan abcde&#92;000fghi a6a10 var1 var2</b>
retournera <b>1</b> avec la cha<68>ne <20>quivalente <20> <b>abcde&#92;000</b> stock<63>e dans <b>var1</b> et <b>var2</b> inchang<6E>e.
</DD>
<DT><b>A</b></DT><DD>Cette forme est la m<>me que <b>a</b>, except<70> que les espaces et les nulls sont enlev<65>s de la valeur scann<6E>e avant d'<27>tre stock<63> dans la variable.&nbsp; Par exemple,
<b>binary scan &quot;abc efghi &#92;000&quot; A* var1</b>
renverra <b>1</b> avec <b>abc efghi</b> stock<63> dans&nbsp; <b>var1</b>.
</DD>
<DT><b>b</b></DT><DD>Les donn<6E>es sont transform<72>es en une cha<68>ne de <i>compte</i> chiffres binaires de bas en haut represent<6E>s comme une s<>quence de caract<63>res &quot;1&quot; et &quot;0&quot;. Les octets de donn<6E>es sont scann<6E>es du premier au dernier avec les bits rang<6E>s de bas en haut pour chaque octet. Les bits suppl<70>mentaires dans le dernier octet sont ignor&eacutes;. Si <i>compte</i> est <b>*</b>, alors tous les bits restant dans <A HREF="165.htm"><b>string</b></A> seront scann<6E>s. Si <i>compte</i> est omis, alors un bit sera scann<6E>.Par exemple,
<b>binary scan&#92;x07&#92;x87&#92;x05 b5b* var1 var2</b>
renverra <b>2</b> avec <b>11100</b> stock<63> dans <b>var1</b> et <b>1110000110100000</b> stock<63> dans <b>var2</b>.
</DD>
<DT><b>B</b></DT><DD>Cette forme est la m<>me que <b>b</b>, except<70> que les bits sont stock<63>s dans l'ordre descendant dans chaque octet. Par exemple,
<b>binary scan&#92;x70&#92;x87&#92;x05 B5B* var1 var2</b>
renverra <b>2</b> avec <b>01110</b> stock<63> dans&nbsp; <b>var1</b> et <b>1000011100000101</b> stock<63> dans <b>var2</b>.
</DD>
<DT><b>h</b></DT><DD>Les donn<6E>es sont transform<72>es en une cha<68>ne de <i>compte</i> chiffres hexad<61>cimaux dans l'ordre de bas en haut represent<6E>s par une s<>quence de caract<63>res de &quot;0123456789abcdef&quot;. Les octets de donn<6E>es sont scann<6E>s du premier au dernier avec les chiffres hexa extraits de bas en haut dans chaque octet. Les bits suppl<70>mentaires dans le dernier octet sont ignor<6F>s. Si <i>compte</i> est <b>*</b>, alors tous les chiffres hexa restant dans <A HREF="165.htm"><b>string</b></A> sont scann<6E>s. Si <i>compte</i> est omis, alors un digit hexa sera scann<6E>. Par exemple,
<b>binary scan&#92;x07&#92;x86&#92;x05 h3h* var1 var2</b>
renverra <b>2</b> avec <b>706</b> stock<63> dans <b>var1</b> et <b>50</b> stock<63> dans <b>var2</b>.
</DD>
<DT><b>H</b></DT><DD>Cette forme est la m<>me que <b>h</b>, except<70> que les chiffres sont extraits de haut en bas dans chaque octet. Par exemple,
<b>binary scan&#92;x07&#92;x86&#92;x05 H3H* var1 var2</b>
renverra <b>2</b> avec <b>078</b> stock<63> dans <b>var1</b> et <b>05</b> stock<63> dans <b>var2</b>.
</DD>
<DT><b>c</b></DT><DD>Les donn<6E>es sont transform<72>es en <i>compte</i> entiers sign<67>s 8-bit et stock<63>es dans la variable correspondante sous forme de liste. Si <i>compte</i> est <b>*</b>, alors tous les octets restant de <A HREF="165.htm"><b>string</b></A> seront scann<6E>s. Si <i>compte</i> est omis, alors un entier 8-bit sera scann<6E>. Par exemple,
<b>binary scan&#92;x07&#92;x86&#92;x05 c2c* var1 var2</b>
renverra <b>2</b> avec <b>7 -122</b> stock<63> dans <b>var1</b> et <b>5</b> stock<63> dans <b>var2</b>. Notez que les entiers renvoy<6F>s sont sign<67>s, mais ils peuvent <20>tre convertis en entiers 8-bit non sign<67>es en utilisant une expression telle que:
<b>expr ( &#36;num + 0x100 ) % 0x100</b>
</DD>
<DT><b>s</b></DT><DD>Les donn<6E>es sont interpr<70>t<EFBFBD>es comme <i>compte</i> entiers sign<67>s 16-bit represent<6E> en little-endian.&nbsp; Les entiers sont stock<63>s dans la variable correspondante sous forme de liste. Si <i>compte</i> est <b>*</b>, alors tous les octets restants de <A HREF="165.htm"><b>string</b></A> seront scann<6E>s. Si <i>compte</i> est omis, alors un entier 16-bit sera scann<6E>. Par exemple,
<b>binary scan&#92;x05&#92;x00&#92;x07&#92;x00&#92;xf0&#92;xff s2s* var1 var2</b>
renverra <b>2</b> avec <b>5 7</b> stock<63> dans <b>var1</b> et <b>-16</b> stock<63> dans <b>var2</b>.Notez que les entiers renvoy<6F>s sont sign<67>s, mais ils peuvent <20>tre convertis en entiers 16-bit non sign<67>es en utilisant une expression telle que:
<b>expr ( &#36;num + 0x10000 ) % 0x10000</b>
</DD>
<DT><b>S</b></DT><DD>Cette forme est la m<>me que <b>s</b> except<70> que les donn<6E>es sont interpr<70>t<EFBFBD>es comme <i>compte</i> entiers 16-bit sign<67>s represent<6E> en big-endian.&nbsp; Par exemple,
<b>binary scan&#92;x00&#92;x05&#92;x00&#92;x07&#92;xff&#92;xf0 S2S* var1 var2</b>
renverra <b>2</b> avec <b>5 7</b> stock<63> dans <b>var1</b> et <b>-16</b> stock<63> dans <b>var2</b>.
</DD>
<DT><b>i</b></DT><DD>Les donn<6E>es sont interpr<70>t<EFBFBD>es comme <i>compte</i> entiers 32-bit sign<67>s represent<6E>s en little-endian. Les entiers sont stock<63>s dans la variable correspondante sous forme de liste. Si <i>compte</i> est <b>*</b>, alors tous octets restants de <A HREF="165.htm"><b>string</b></A> seront scann<6E>s. Si <i>compte</i> est omis, alors un entier 32-bit sera scann<6E>. Par exemple,
<b>binary scan&#92;x05&#92;x00&#92;x00&#92;x00&#92;x07&#92;x00&#92;x00&#92;x00&#92;xf0&#92;xff&#92;xff&#92;xff </b><b>i2i* var1 var2</b>
renverra <b>2</b> avec <b>5 7</b> stock<63> dans <b>var1</b> et <b>-16</b> stock<63> dans <b>var2</b>. Notez que les entiers renvoy<6F>s sont sign<67>s et ne peuvent pas <20>tre represent<6E>s par Tcl comme valeurs non sign<67>es.
</DD>
<DT><b>I</b></DT><DD>Cette forme est la m<>me que <b>i</b> except<70> que les donn<6E>es sont&nbsp; interpr<70>t<EFBFBD>es comme <i>compte</i> entiers 32-bit sign<67>s represent<6E> en big-endian.&nbsp; Par exemple,
<b>binary&#92;x00&#92;x00&#92;x00&#92;x05&#92;x00&#92;x00&#92;x00&#92;x07&#92;xff&#92;xff&#92;xff&#92;xf0 I2I* </b><b>var1 var2</b>
renverra <b>2</b> avec <b>5 7</b> stock<63> dans <b>var1</b> et <b>-16</b> stock<63> dans <b>var2</b>.
</DD>
<DT><b>f</b></DT><DD>Les donn<6E>es sont interpr<70>t<EFBFBD>es comme <i>compte</i> nombre flottants simple-pr<70>cision dans la repr<70>sentation native de la machine.&nbsp; Les nombres flottants sont stock<63>s dans la variable correspondante sous forme de liste.&nbsp; Si <i>compte</i> est <b>*</b>, alors tous les octets restants de <A HREF="165.htm"><b>string</b></A> seront scann<6E>s. Si <i>compte</i> est omis, alors un nombre flottant simple-pr<70>cision sera scann<6E>. La taille d'un nombre flottant peut varier selon les architectures, donc le nombre d'octets scann<6E>s peut varier. Si les donn<6E>es ne repr<70>sentent pas un nombre flottant valide, la valeur r<>sultante est ind<6E>finie et d<>pend du compilateur. Par exemple, sur un syst<73>me Windows s'ex<65>cutant sur un processeur Pentium Intel,
<b>binary scan&#92;x3f&#92;xcc&#92;xcc&#92;xcd f var1</b>
>renverra <b>1</b> avec <b>1.6000000238418579</b> stock<63> dans <b>var1</b>.
</DD>
<DT><b>d</b></DT><DD>Cette forme est la m<>me que <b>f</b> except<70> que les donn<6E>es sont interpr<70>t<EFBFBD>es comme <i>compte</i> nombre flottants double-precision dans la repr<70>sentation native de la machine. Par exemple, , sur un syst<73>me Windows s'ex<65>cutant sur un processeur Pentium Intel,
<b>binary scan&#92;x9a&#92;x99&#92;x99&#92;x99&#92;x99&#92;x99&#92;xf9&#92;x3f d var1</b>
renverra <b>1</b> avec <b>1.6000000000000001</b> stock<63> dans <b>var1</b>.
</DD>
<DT><b>x</b></DT><DD>D<EFBFBD>place le curseur en avant de <i>compte</i> octets dans <i>string</i>. Si <i>compte</i> est <b>*</b> ou est sup<75>rieur au nombre d'octets apr<70>s la position courante du curseur, alors le curseur est positionn<6E> apr<70>s le dernier octet de <i>string</i>.&nbsp; Si <i>compte</i> est omis, alors le curseur est d<>plac<61> en avant d'un octet. Notez que ce type n'attend pas d'argument. Par exemple,
<b>binary scan&#92;x01&#92;x02&#92;x03&#92;x04 x2H* var1</b>
renverra <b>1</b> avec <b>0304</b> stock<63> dans <b>var1</b>.
</DD>
<DT><b>X</b></DT><DD>D<EFBFBD>place le curseur en arri<72>re de&nbsp; <i>compte</i> octets dans <i>string</i>. Si <i>compte</i> est <b>*</b> ou est sup<75>rieur <20> la position courante du curseur, alors le curseur est positionn<6E> <20> la position 0 de telle sorte que le prochain octet scann<6E> sera le premier octet de <i>string</i>. Si <i>compte</i> est omis alors le curseur est d<>plac<61> en arri<72>re d'un octet.&nbsp; Notez que ce type n'attend pas d'argument.&nbsp; Par exemple,
<b>binary scan&#92;x01&#92;x02&#92;x03&#92;x04 c2XH* var1 var2</b>
renverra <b>2</b> avec <b>1 2</b> stock<63> dans <b>var1</b> et <b>020304</b> stock<63> dans <b>var2</b>.
</DD>
<DT><b>@</b></DT><DD>D<EFBFBD>place le curseur <20> la position absolu de la cha<68>ne sp<73>cifi<66>e par <i>compte</i>. Notez que la position 0 correspondante au premier octet de <i>string</i>. Si <i>compte</i> correspond <20> une position au-dela de la fin de <i>string</i>, alors le curseur est positionn<6E> apr<70>s le dernier octet. Si <i>compte</i> est omis, alors une erreur est g<>n<EFBFBD>r<EFBFBD>e. Par exemple,
<b>binary scan&#92;x01&#92;x02&#92;x03&#92;x04 c2@1H* var1 var2</b>
renverra <b>2</b> avec <b>1 2</b> stock<63> dans <b>var1</b> et <b>020304</b> stock<63> dans <b>var2</b>.<br>
</DD>
</DL>
</div>
<div><b>PLATFORM ISSUES</b></div><br>
<div ALIGN="LEFT" style="margin-left: 51px;">Il est parfois souhaitable de formater ou scanner des valeur enti<74>res dans l'ordre natif des octets de la machine. R<>f<EFBFBD>rez vous <20> l'<27>l<EFBFBD>ment <b>byteOrder</b> du tableau <b>tcl_platform</b> pour conna<6E>tre le caract<63>re <20> utiliser pour formater ou scanner des entiers.
</div><br>
<div><b>VOIR EGALEMENT</b></div><br>
<div ALIGN="LEFT" style="margin-left: 51px;"><A HREF="117.htm">format</A>, <A HREF="159.htm">scan</A>, <A HREF="170.htm">tclvars</A> </div>
<div>Derni<EFBFBD>re r<>vision: 8.0</div>
<br>
<br><div ALIGN="CENTER"><A HREF="index.htm"><b>Index</b></A>&nbsp;&nbsp;<A HREF="90.htm"><b>Pr<EFBFBD>c<EFBFBD>dent</b></A>&nbsp;&nbsp;<A HREF="92.htm"><b>Suivant</b></A>
</div>
</BODY></HTML>