179 lines
24 KiB
HTML
179 lines
24 KiB
HTML
|
<HTML><HEAD>
|
|||
|
|
<BASEFONT FACE="Times New Roman" SIZE="2" COLOR="#000000">
|
|||
|
|
</HEAD>
|
|||
|
|
<BODY>
|
|||
|
|
<div><H3><b>binary 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. 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 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>. 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\000\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 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. 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 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>\x07\x87\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>\xe0\xe1\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. <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. 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. Si <i>compte</i> est <b>*</b>, alors tous les chiffres de <i>arg</i> seront format<61>s. Si <i>compte</i> est omis, alors un digit est format<61>. 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>\xba\x00\xed\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 haut en bas dans chaque octet. Par exemple,
|
|||
|
|
<b>binary format H3H* ab DEF</b>
|
|||
|
|
renverra une cha<68>ne <20>quivalente <20> <b>\xab\x00\xde\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. 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. Les 8 bits de poids faible de chaque entier sont stock<63>s comme une valeur d'un octet <20> la position du curseur. Si <i>compte</i> est <b>*</b>, alors tous les entiers de la liste sont format<61>s. 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. 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. Par exemple,
|
|||
|
|
<b>binary format c3cc* {3 -3 128 1} 260 {2 5}</b>
|
|||
|
|
renverra une cha<68>ne <20>quivalente <20> <b>\x03\xfd\x80\x04\x02\x05</b>, alors que
|
|||
|
|
<b>binary format c {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. Par exemple,
|
|||
|
|
<b>binary format s3 {3 -3 258 1}</b>
|
|||
|
|
renverra une cha<68>ne <20>quivalente <20> <b>\x03\x00\xfd\xff\x02\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. Par exemple,
|
|||
|
|
<b>binary format S3 {3 -3 258 1}</b>
|
|||
|
|
renverra une cha<68>ne <20>quivalente <20> <b>\x00\x03\xff\xfd\x01\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 {3 -3 65536 1}</b>
|
|||
|
|
renverra une cha<68>ne <20>quivalente <20> <b>\x03\x00\x00\x00\xfd\xff\xff\xff\x00\x00\x01\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 {3 -3 65536 1}</b>
|
|||
|
|
renverra une cha<68>ne <20>quivalente <20> <b>\x00\x00\x00\x03\xff\xff\xff\xfd\x00\x01\x00\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 {1.6 3.4}</b>
|
|||
|
|
renverra une cha<68>ne <20>quivalente <20><b>\xcd\xcc\xcc\x3f\x9a\x99\x59\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. Par exemple, sur un syst<73>me Windows s'ex<65>cutant sur un processeur Pentium Intel,
|
|||
|
|
<b>binary format d1 {1.6}</b>
|
|||
|
|
renverra une cha<68>ne <20>quivalente <20> <b>\x9a\x99\x99\x99\x99\x99\xf9\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. 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\000def\000\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. 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. La position 0 correspond au premier octet dans la cha<68>ne de sortie. Si <i>compte</i> correspond <20> une position au-dela du dernier octet stock<63>, alors des octet nuls seront plac<61>s aux emplacements non initalis<69>s et le curseur sera plac<61> <20> l'emplacement sp<73>cifi<66>. 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. 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\000\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. <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. 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 utilisent un argument pour obtenir la variable dans laquelle les valeurs seront plac<61>es. Le caract<63>re sp<73>cifie comment les donn<6E>es binaires sont interpr<70>t<EFBFBD>es. Le <i>compte</i> indique typiquement combien d'examplaires du type sp<73>cifi<66> sont extraits des donn<6E>es. 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. Ce faisant, les entiers qui ont leurs bit haut 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 [binary format s1 0x8000]</b><br>
|
|||
|
|
<b>binary scan $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. Par exemple, pour produire un entier court non sign<67>e: </div>
|
|||
|
|
<div ALIGN="LEFT" style="margin-left: 102px;"><b>set val [expr {$val & 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. 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>. Si <i>compte</i> est <b>*</b>, alors tous les octets restants dans <i>string</i> seront scann<6E>s dans la variable. Si <i>compte</i> est omis, alors un caract<63>re sera scann<6E>. Par exemple,
|
|||
|
|
<b>binary scan abcde\000fghi a6a10 var1 var2</b>
|
|||
|
|
retournera <b>1</b> avec la cha<68>ne <20>quivalente <20> <b>abcde\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. Par exemple,
|
|||
|
|
<b>binary scan "abc efghi \000" A* var1</b>
|
|||
|
|
renverra <b>1</b> avec <b>abc efghi</b> stock<63> dans <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 "1" et "0". 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és;. 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\x07\x87\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\x70\x87\x05 B5B* var1 var2</b>
|
|||
|
|
renverra <b>2</b> avec <b>01110</b> stock<63> dans <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 "0123456789abcdef". 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\x07\x86\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\x07\x86\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\x07\x86\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 ( $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. 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\x05\x00\x07\x00\xf0\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 ( $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. Par exemple,
|
|||
|
|
<b>binary scan\x00\x05\x00\x07\xff\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\x05\x00\x00\x00\x07\x00\x00\x00\xf0\xff\xff\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 interpr<70>t<EFBFBD>es comme <i>compte</i> entiers 32-bit sign<67>s represent<6E> en big-endian. Par exemple,
|
|||
|
|
<b>binary\x00\x00\x00\x05\x00\x00\x00\x07\xff\xff\xff\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. Les nombres flottants 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 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\x3f\xcc\xcc\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\x9a\x99\x99\x99\x99\x99\xf9\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>. 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\x01\x02\x03\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 <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. Notez que ce type n'attend pas d'argument. Par exemple,
|
|||
|
|
<b>binary scan\x01\x02\x03\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\x01\x02\x03\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> <A HREF="90.htm"><b>Pr<EFBFBD>c<EFBFBD>dent</b></A> <A HREF="92.htm"><b>Suivant</b></A>
|
|||
|
|
</div>
|
|||
|
|
</BODY></HTML>
|