Est-il possible avoir un code en C capable de detecter le type de
processeur, en de lui forcer l'ecriture ou la lecture d'un fichier
binnaire en little ou big endian indifferement ???
Est-il possible avoir un code en C capable de detecter le type de processeur, en de lui forcer l'ecriture ou la lecture d'un fichier binnaire en little ou big endian indifferement ???
Merci David
Pourquoi pas en écrivant un int en mémoire, puis en le relisant octet
par octet ? Ainsi on peut obtenir l'ordre dans lequel ils ont été écrits, et donc l'endianness du système ... J'ai bon ? :)
Florent "flure" Curé
Est-il possible avoir un code en C capable de detecter le type de
processeur, en de lui forcer l'ecriture ou la lecture d'un fichier
binnaire en little ou big endian indifferement ???
Merci
David
Pourquoi pas en écrivant un int en mémoire, puis en le relisant octet
par octet ? Ainsi on peut obtenir l'ordre dans lequel ils ont été
écrits, et donc l'endianness du système ...
J'ai bon ? :)
Est-il possible avoir un code en C capable de detecter le type de processeur, en de lui forcer l'ecriture ou la lecture d'un fichier binnaire en little ou big endian indifferement ???
Merci David
Pourquoi pas en écrivant un int en mémoire, puis en le relisant octet
par octet ? Ainsi on peut obtenir l'ordre dans lequel ils ont été écrits, et donc l'endianness du système ... J'ai bon ? :)
Florent "flure" Curé
Jean-Marc Bourguet
David ROMAN writes:
Est-il possible avoir un code en C capable de detecter le type de processeur,
Toute valeur peut etre relue comme un tableau d'unsigned char. Donc
void hexdump(void* p, size_t n, FILE* fp) { int i; unsigned char* cp = p; for (i = 0; i < n; ++i, ++cp) { fprintf(fp, "%2x", *cp); } }
est valide.
en de lui forcer l'ecriture ou la lecture d'un fichier binnaire en little ou big endian indifferement ???
Non. Les IO en C sont soit formattees (et donc c'est a interpreter comme des caracteres) soit non typees (donc on utilise la propiete ci-dessus) et comme la transformation a faire depend du type (et parfois elle est meme pas definie -- pour union { short s1, s2; int i; } par exemple) ce n'est meme pas conceptuellement possible.
La bonne solution est de toute maniere de definir son format explicitement et de sortir ou lire des bytes en fonction de celui-ci. On n'a meme pas a avoir du code different pour les differentes plateformes.
A+
-- Jean-Marc FAQ de fclc: http://www.isty-info.uvsq.fr/~rumeau/fclc Site de usenet-fr: http://www.usenet-fr.news.eu.org
David ROMAN <roman@cesr.fr> writes:
Est-il possible avoir un code en C capable de detecter le type de
processeur,
Toute valeur peut etre relue comme un tableau d'unsigned char.
Donc
void hexdump(void* p, size_t n, FILE* fp) {
int i;
unsigned char* cp = p;
for (i = 0; i < n; ++i, ++cp) {
fprintf(fp, "%2x", *cp);
}
}
est valide.
en de lui forcer l'ecriture ou la lecture d'un fichier binnaire en
little ou big endian indifferement ???
Non. Les IO en C sont soit formattees (et donc c'est a interpreter
comme des caracteres) soit non typees (donc on utilise la propiete
ci-dessus) et comme la transformation a faire depend du type (et
parfois elle est meme pas definie -- pour union { short s1, s2; int i; }
par exemple) ce n'est meme pas conceptuellement possible.
La bonne solution est de toute maniere de definir son format
explicitement et de sortir ou lire des bytes en fonction de celui-ci.
On n'a meme pas a avoir du code different pour les differentes
plateformes.
A+
--
Jean-Marc
FAQ de fclc: http://www.isty-info.uvsq.fr/~rumeau/fclc
Site de usenet-fr: http://www.usenet-fr.news.eu.org
Est-il possible avoir un code en C capable de detecter le type de processeur,
Toute valeur peut etre relue comme un tableau d'unsigned char. Donc
void hexdump(void* p, size_t n, FILE* fp) { int i; unsigned char* cp = p; for (i = 0; i < n; ++i, ++cp) { fprintf(fp, "%2x", *cp); } }
est valide.
en de lui forcer l'ecriture ou la lecture d'un fichier binnaire en little ou big endian indifferement ???
Non. Les IO en C sont soit formattees (et donc c'est a interpreter comme des caracteres) soit non typees (donc on utilise la propiete ci-dessus) et comme la transformation a faire depend du type (et parfois elle est meme pas definie -- pour union { short s1, s2; int i; } par exemple) ce n'est meme pas conceptuellement possible.
La bonne solution est de toute maniere de definir son format explicitement et de sortir ou lire des bytes en fonction de celui-ci. On n'a meme pas a avoir du code different pour les differentes plateformes.
A+
-- Jean-Marc FAQ de fclc: http://www.isty-info.uvsq.fr/~rumeau/fclc Site de usenet-fr: http://www.usenet-fr.news.eu.org
Laurent Deniau
Jean-Marc Bourguet wrote:
David ROMAN writes:
Est-il possible avoir un code en C capable de detecter le type de processeur,
Toute valeur peut etre relue comme un tableau d'unsigned char. Donc
void hexdump(void* p, size_t n, FILE* fp) { int i; unsigned char* cp = p; for (i = 0; i < n; ++i, ++cp) { fprintf(fp, "%2x", *cp); } }
est valide.
La j'ai un gros doute. Quelle est la difference avec un fwrite(p, 1, size, fp) hormis le formatage en hexa (quel interet d'ailleurs)?
a+, ld.
Jean-Marc Bourguet wrote:
David ROMAN <roman@cesr.fr> writes:
Est-il possible avoir un code en C capable de detecter le type de
processeur,
Toute valeur peut etre relue comme un tableau d'unsigned char.
Donc
void hexdump(void* p, size_t n, FILE* fp) {
int i;
unsigned char* cp = p;
for (i = 0; i < n; ++i, ++cp) {
fprintf(fp, "%2x", *cp);
}
}
est valide.
La j'ai un gros doute. Quelle est la difference avec un fwrite(p, 1,
size, fp) hormis le formatage en hexa (quel interet d'ailleurs)?
Est-il possible avoir un code en C capable de detecter le type de processeur,
Toute valeur peut etre relue comme un tableau d'unsigned char. Donc
void hexdump(void* p, size_t n, FILE* fp) { int i; unsigned char* cp = p; for (i = 0; i < n; ++i, ++cp) { fprintf(fp, "%2x", *cp); } }
est valide.
La j'ai un gros doute. Quelle est la difference avec un fwrite(p, 1, size, fp) hormis le formatage en hexa (quel interet d'ailleurs)?
a+, ld.
Jean-Marc Bourguet
Laurent Deniau writes:
Jean-Marc Bourguet wrote:
David ROMAN writes:
Est-il possible avoir un code en C capable de detecter le type de processeur, Toute valeur peut etre relue comme un tableau d'unsigned char.
Donc void hexdump(void* p, size_t n, FILE* fp) { int i; unsigned char* cp = p; for (i = 0; i < n; ++i, ++cp) { fprintf(fp, "%2x", *cp); } } est valide.
La j'ai un gros doute.
Pourquoi?
Quelle est la difference avec un fwrite(p, 1, size, fp) hormis le formatage en hexa (quel interet d'ailleurs)?
Le fait qu'un tel acces est possible en dehors d'une fonction de la bibliotheque.
A+
-- Jean-Marc FAQ de fclc: http://www.isty-info.uvsq.fr/~rumeau/fclc Site de usenet-fr: http://www.usenet-fr.news.eu.org
Laurent Deniau <Laurent.Deniau@cern.ch> writes:
Jean-Marc Bourguet wrote:
David ROMAN <roman@cesr.fr> writes:
Est-il possible avoir un code en C capable de detecter le type de
processeur,
Toute valeur peut etre relue comme un tableau d'unsigned char.
Donc
void hexdump(void* p, size_t n, FILE* fp) {
int i;
unsigned char* cp = p;
for (i = 0; i < n; ++i, ++cp) {
fprintf(fp, "%2x", *cp);
}
}
est valide.
La j'ai un gros doute.
Pourquoi?
Quelle est la difference avec un fwrite(p, 1, size, fp) hormis le
formatage en hexa (quel interet d'ailleurs)?
Le fait qu'un tel acces est possible en dehors d'une fonction de la
bibliotheque.
A+
--
Jean-Marc
FAQ de fclc: http://www.isty-info.uvsq.fr/~rumeau/fclc
Site de usenet-fr: http://www.usenet-fr.news.eu.org
Est-il possible avoir un code en C capable de detecter le type de processeur, Toute valeur peut etre relue comme un tableau d'unsigned char.
Donc void hexdump(void* p, size_t n, FILE* fp) { int i; unsigned char* cp = p; for (i = 0; i < n; ++i, ++cp) { fprintf(fp, "%2x", *cp); } } est valide.
La j'ai un gros doute.
Pourquoi?
Quelle est la difference avec un fwrite(p, 1, size, fp) hormis le formatage en hexa (quel interet d'ailleurs)?
Le fait qu'un tel acces est possible en dehors d'une fonction de la bibliotheque.
A+
-- Jean-Marc FAQ de fclc: http://www.isty-info.uvsq.fr/~rumeau/fclc Site de usenet-fr: http://www.usenet-fr.news.eu.org
Yves ROMAN
Est-il possible avoir un code en C capable de detecter le type de processeur, en de lui forcer l'ecriture ou la lecture d'un fichier binnaire en little ou big endian indifferement ???
Pourquoi pas en écrivant un int en mémoire, puis en le relisant octet
par octet ? Ainsi on peut obtenir l'ordre dans lequel ils ont été écrits, et donc l'endianness du système ... J'ai bon ? :)
Par exemple :
int isIntel(void) { long l = 1 ; return *((char *)(&l)) ; }
Est-il possible avoir un code en C capable de detecter le type de
processeur, en de lui forcer l'ecriture ou la lecture d'un fichier
binnaire en little ou big endian indifferement ???
Pourquoi pas en écrivant un int en mémoire, puis en le relisant octet
par octet ? Ainsi on peut obtenir l'ordre dans lequel ils ont été
écrits, et donc l'endianness du système ...
J'ai bon ? :)
Par exemple :
int isIntel(void)
{
long l = 1 ;
return *((char *)(&l)) ;
}
Est-il possible avoir un code en C capable de detecter le type de processeur, en de lui forcer l'ecriture ou la lecture d'un fichier binnaire en little ou big endian indifferement ???
Pourquoi pas en écrivant un int en mémoire, puis en le relisant octet
par octet ? Ainsi on peut obtenir l'ordre dans lequel ils ont été écrits, et donc l'endianness du système ... J'ai bon ? :)
Par exemple :
int isIntel(void) { long l = 1 ; return *((char *)(&l)) ; }
Laurent Deniau
Jean-Marc Bourguet wrote:
Laurent Deniau writes:
Jean-Marc Bourguet wrote:
David ROMAN writes:
Est-il possible avoir un code en C capable de detecter le type de processeur,
Toute valeur peut etre relue comme un tableau d'unsigned char. Donc void hexdump(void* p, size_t n, FILE* fp) { int i; unsigned char* cp = p; for (i = 0; i < n; ++i, ++cp) { fprintf(fp, "%2x", *cp); } } est valide.
La j'ai un gros doute.
Pourquoi?
Parce que si c'etait aussi simple, XDR n'existerait pas. Selon toi, le code:
long a = 3; hexdump(&a, sizeof a, file);
permet d'ecrire un long dans file de maniere portable? Qu'en est-il des flottants, tableaux et autres?
a+, ld.
Jean-Marc Bourguet wrote:
Laurent Deniau <Laurent.Deniau@cern.ch> writes:
Jean-Marc Bourguet wrote:
David ROMAN <roman@cesr.fr> writes:
Est-il possible avoir un code en C capable de detecter le type de
processeur,
Toute valeur peut etre relue comme un tableau d'unsigned char.
Donc
void hexdump(void* p, size_t n, FILE* fp) {
int i;
unsigned char* cp = p;
for (i = 0; i < n; ++i, ++cp) {
fprintf(fp, "%2x", *cp);
}
}
est valide.
La j'ai un gros doute.
Pourquoi?
Parce que si c'etait aussi simple, XDR n'existerait pas. Selon toi, le code:
long a = 3;
hexdump(&a, sizeof a, file);
permet d'ecrire un long dans file de maniere portable? Qu'en est-il des
flottants, tableaux et autres?
Est-il possible avoir un code en C capable de detecter le type de processeur,
Toute valeur peut etre relue comme un tableau d'unsigned char. Donc void hexdump(void* p, size_t n, FILE* fp) { int i; unsigned char* cp = p; for (i = 0; i < n; ++i, ++cp) { fprintf(fp, "%2x", *cp); } } est valide.
La j'ai un gros doute.
Pourquoi?
Parce que si c'etait aussi simple, XDR n'existerait pas. Selon toi, le code:
long a = 3; hexdump(&a, sizeof a, file);
permet d'ecrire un long dans file de maniere portable? Qu'en est-il des flottants, tableaux et autres?
a+, ld.
Yves ROMAN
Est-il possible avoir un code en C capable de detecter le type de processeur, en de lui forcer l'ecriture ou la lecture d'un fichier binnaire en little ou big endian indifferement ???
Tu peux écrire une fonction qui te dit si ta machine est en little ou big
endian.
int isIntel(void) { long l = 1 ; return *((char *)(&l)) ; }
Mais rien ne te dis dans quel format est le fichier que tu lis. (A moins d'avoir un champ en tête qui précise le format)
Pour lire/écrire dans un format différent de celui de ta machine, tu devra convertir chaque donnée une par une : pas de configuration possible des fonctions de lecture qui lisent des char.
En outre si ton fichier contient des structures, des formats de padding différents sur les 2 systèmes poseront aussi des problèmes de relecture.
Si tu peux choisir le format de fichier, écrit/lit plutôt les données une par une. Si possible sous forme texte. Si tu dois choisir du binaire, choisit le format réseau, et utilise les fonctions hton/ntoh pour encoder/décoder les valeurs avant/après de les écrire/lire
Est-il possible avoir un code en C capable de detecter le type de
processeur, en de lui forcer l'ecriture ou la lecture d'un fichier
binnaire en little ou big endian indifferement ???
Tu peux écrire une fonction qui te dit si ta machine est en little ou big
endian.
int isIntel(void)
{
long l = 1 ;
return *((char *)(&l)) ;
}
Mais rien ne te dis dans quel format est le fichier que tu lis.
(A moins d'avoir un champ en tête qui précise le format)
Pour lire/écrire dans un format différent de celui de ta machine, tu devra
convertir chaque donnée une par une : pas de configuration possible des
fonctions de lecture qui lisent des char.
En outre si ton fichier contient des structures, des formats de padding
différents sur les 2 systèmes poseront aussi des problèmes de relecture.
Si tu peux choisir le format de fichier, écrit/lit plutôt les données une par
une.
Si possible sous forme texte.
Si tu dois choisir du binaire, choisit le format réseau, et utilise les
fonctions hton/ntoh pour encoder/décoder les valeurs avant/après de les
écrire/lire
Est-il possible avoir un code en C capable de detecter le type de processeur, en de lui forcer l'ecriture ou la lecture d'un fichier binnaire en little ou big endian indifferement ???
Tu peux écrire une fonction qui te dit si ta machine est en little ou big
endian.
int isIntel(void) { long l = 1 ; return *((char *)(&l)) ; }
Mais rien ne te dis dans quel format est le fichier que tu lis. (A moins d'avoir un champ en tête qui précise le format)
Pour lire/écrire dans un format différent de celui de ta machine, tu devra convertir chaque donnée une par une : pas de configuration possible des fonctions de lecture qui lisent des char.
En outre si ton fichier contient des structures, des formats de padding différents sur les 2 systèmes poseront aussi des problèmes de relecture.
Si tu peux choisir le format de fichier, écrit/lit plutôt les données une par une. Si possible sous forme texte. Si tu dois choisir du binaire, choisit le format réseau, et utilise les fonctions hton/ntoh pour encoder/décoder les valeurs avant/après de les écrire/lire
Jean-Marc Bourguet
Laurent Deniau writes:
Parce que si c'etait aussi simple, XDR n'existerait pas. Selon toi, le code:
long a = 3; hexdump(&a, sizeof a, file);
permet d'ecrire un long dans file de maniere portable?
Non. Je repondais a la question "est-il possible de detecter la 'boutitude' d'un processeur en C de maniere portable". Le code que j'ai donne est conforme et permet de le faire mais son resultat depend justement de la boutitude.
J'ai vraissemblablement ete trop concis (et le suis peut-etre encore).
A+
-- Jean-Marc FAQ de fclc: http://www.isty-info.uvsq.fr/~rumeau/fclc Site de usenet-fr: http://www.usenet-fr.news.eu.org
Laurent Deniau <Laurent.Deniau@cern.ch> writes:
Parce que si c'etait aussi simple, XDR n'existerait pas. Selon toi, le code:
long a = 3;
hexdump(&a, sizeof a, file);
permet d'ecrire un long dans file de maniere portable?
Non. Je repondais a la question "est-il possible de detecter la
'boutitude' d'un processeur en C de maniere portable". Le code que
j'ai donne est conforme et permet de le faire mais son resultat depend
justement de la boutitude.
J'ai vraissemblablement ete trop concis (et le suis peut-etre encore).
A+
--
Jean-Marc
FAQ de fclc: http://www.isty-info.uvsq.fr/~rumeau/fclc
Site de usenet-fr: http://www.usenet-fr.news.eu.org
Parce que si c'etait aussi simple, XDR n'existerait pas. Selon toi, le code:
long a = 3; hexdump(&a, sizeof a, file);
permet d'ecrire un long dans file de maniere portable?
Non. Je repondais a la question "est-il possible de detecter la 'boutitude' d'un processeur en C de maniere portable". Le code que j'ai donne est conforme et permet de le faire mais son resultat depend justement de la boutitude.
J'ai vraissemblablement ete trop concis (et le suis peut-etre encore).
A+
-- Jean-Marc FAQ de fclc: http://www.isty-info.uvsq.fr/~rumeau/fclc Site de usenet-fr: http://www.usenet-fr.news.eu.org
James Kanze
Yves ROMAN writes:
|> > Est-il possible avoir un code en C capable de detecter le type de |> > processeur, en de lui forcer l'ecriture ou la lecture d'un fichier |> > binnaire en little ou big endian indifferement ???
|> Tu peux écrire une fonction qui te dit si ta machine est en little |> ou big endian.
|> int isIntel(void) |> { |> long l = 1 ; |> return *((char *)(&l)) ; |> }
Je suis un peu curieux en ce qui concerne le nom. Après tout, la fonction renvoie la même chose, que ce soit un processeur Intel ou un VAX.
Je suis aussi curieux de ce qu'on pourrait faire d'une telle information. Après tout, il reste beaucoup qu'elle ne me dit pas. (Que renvoie-t-elle, par exemple, sur un Unisys 2200 ?)
|> Mais rien ne te dis dans quel format est le fichier que tu lis. (A |> moins d'avoir un champ en tête qui précise le format)
Si tu ne sais pas le format du fichier, tu vas avoir du mal à le lire. Et à l'écrire correctement, aussi.
|> Pour lire/écrire dans un format différent de celui de ta machine, tu |> devra convertir chaque donnée une par une : pas de configuration |> possible des fonctions de lecture qui lisent des char.
|> En outre si ton fichier contient des structures, des formats de |> padding différents sur les 2 systèmes poseront aussi des problèmes |> de relecture.
|> Si tu peux choisir le format de fichier, écrit/lit plutôt les |> données une par une. Si possible sous forme texte. Si tu dois |> choisir du binaire, choisit le format réseau, et utilise les |> fonctions hton/ntoh pour encoder/décoder les valeurs avant/après de |> les écrire/lire
Et si ces fonctions ne sont pas disponibles ? (En fait, elles ne servent absolument à rien si tu connais le format du fichier, et à encore moins si tu ne le connais pas.)
-- James Kanze Conseils en informatique orientée objet/ Beratung in objektorientierter Datenverarbeitung 9 place Sémard, 78210 St.-Cyr-l'École, France +33 (0)1 30 23 00 34
Yves ROMAN <yves.roman@NO.unilog.SPAM.fr> writes:
|> > Est-il possible avoir un code en C capable de detecter le type de
|> > processeur, en de lui forcer l'ecriture ou la lecture d'un fichier
|> > binnaire en little ou big endian indifferement ???
|> Tu peux écrire une fonction qui te dit si ta machine est en little
|> ou big endian.
|> int isIntel(void)
|> {
|> long l = 1 ;
|> return *((char *)(&l)) ;
|> }
Je suis un peu curieux en ce qui concerne le nom. Après tout, la
fonction renvoie la même chose, que ce soit un processeur Intel ou un
VAX.
Je suis aussi curieux de ce qu'on pourrait faire d'une telle
information. Après tout, il reste beaucoup qu'elle ne me dit pas. (Que
renvoie-t-elle, par exemple, sur un Unisys 2200 ?)
|> Mais rien ne te dis dans quel format est le fichier que tu lis. (A
|> moins d'avoir un champ en tête qui précise le format)
Si tu ne sais pas le format du fichier, tu vas avoir du mal à le lire.
Et à l'écrire correctement, aussi.
|> Pour lire/écrire dans un format différent de celui de ta machine, tu
|> devra convertir chaque donnée une par une : pas de configuration
|> possible des fonctions de lecture qui lisent des char.
|> En outre si ton fichier contient des structures, des formats de
|> padding différents sur les 2 systèmes poseront aussi des problèmes
|> de relecture.
|> Si tu peux choisir le format de fichier, écrit/lit plutôt les
|> données une par une. Si possible sous forme texte. Si tu dois
|> choisir du binaire, choisit le format réseau, et utilise les
|> fonctions hton/ntoh pour encoder/décoder les valeurs avant/après de
|> les écrire/lire
Et si ces fonctions ne sont pas disponibles ? (En fait, elles ne servent
absolument à rien si tu connais le format du fichier, et à encore moins
si tu ne le connais pas.)
--
James Kanze
Conseils en informatique orientée objet/
Beratung in objektorientierter Datenverarbeitung
9 place Sémard, 78210 St.-Cyr-l'École, France +33 (0)1 30 23 00 34
|> > Est-il possible avoir un code en C capable de detecter le type de |> > processeur, en de lui forcer l'ecriture ou la lecture d'un fichier |> > binnaire en little ou big endian indifferement ???
|> Tu peux écrire une fonction qui te dit si ta machine est en little |> ou big endian.
|> int isIntel(void) |> { |> long l = 1 ; |> return *((char *)(&l)) ; |> }
Je suis un peu curieux en ce qui concerne le nom. Après tout, la fonction renvoie la même chose, que ce soit un processeur Intel ou un VAX.
Je suis aussi curieux de ce qu'on pourrait faire d'une telle information. Après tout, il reste beaucoup qu'elle ne me dit pas. (Que renvoie-t-elle, par exemple, sur un Unisys 2200 ?)
|> Mais rien ne te dis dans quel format est le fichier que tu lis. (A |> moins d'avoir un champ en tête qui précise le format)
Si tu ne sais pas le format du fichier, tu vas avoir du mal à le lire. Et à l'écrire correctement, aussi.
|> Pour lire/écrire dans un format différent de celui de ta machine, tu |> devra convertir chaque donnée une par une : pas de configuration |> possible des fonctions de lecture qui lisent des char.
|> En outre si ton fichier contient des structures, des formats de |> padding différents sur les 2 systèmes poseront aussi des problèmes |> de relecture.
|> Si tu peux choisir le format de fichier, écrit/lit plutôt les |> données une par une. Si possible sous forme texte. Si tu dois |> choisir du binaire, choisit le format réseau, et utilise les |> fonctions hton/ntoh pour encoder/décoder les valeurs avant/après de |> les écrire/lire
Et si ces fonctions ne sont pas disponibles ? (En fait, elles ne servent absolument à rien si tu connais le format du fichier, et à encore moins si tu ne le connais pas.)
-- James Kanze Conseils en informatique orientée objet/ Beratung in objektorientierter Datenverarbeitung 9 place Sémard, 78210 St.-Cyr-l'École, France +33 (0)1 30 23 00 34
Jean-Marc Bourguet
James Kanze writes:
Yves ROMAN writes:
|> > Est-il possible avoir un code en C capable de detecter le type de |> > processeur, en de lui forcer l'ecriture ou la lecture d'un fichier |> > binnaire en little ou big endian indifferement ???
|> Tu peux écrire une fonction qui te dit si ta machine est en little |> ou big endian.
|> int isIntel(void) |> { |> long l = 1 ; |> return *((char *)(&l)) ; |> }
Je suis un peu curieux en ce qui concerne le nom. Après tout, la fonction renvoie la même chose, que ce soit un processeur Intel ou un VAX.
Ca m'a fait me sentir vieux de voir attriber à Intel plutôt qu'a DEC cet ordre :-)
Je suis aussi curieux de ce qu'on pourrait faire d'une telle information. Après tout, il reste beaucoup qu'elle ne me dit pas. (Que renvoie-t-elle, par exemple, sur un Unisys 2200 ?)
Aucune idée (successeur des Univac 1100, ça doit aussi être une machine 36 bits, complément à 1, adressable par mot non?). Pour un PDP-10 (36 bits, complément à 2, adressable par mot aussi) ça donnerait vraissemblablement 0 (mais je ne les ait pas programmé en C) vu la manière dont les char étaient stockés sur ces machines.
A+
-- Jean-Marc FAQ de fclc: http://www.isty-info.uvsq.fr/~rumeau/fclc Site de usenet-fr: http://www.usenet-fr.news.eu.org
James Kanze <james.kanze@free.fr> writes:
Yves ROMAN <yves.roman@NO.unilog.SPAM.fr> writes:
|> > Est-il possible avoir un code en C capable de detecter le type de
|> > processeur, en de lui forcer l'ecriture ou la lecture d'un fichier
|> > binnaire en little ou big endian indifferement ???
|> Tu peux écrire une fonction qui te dit si ta machine est en little
|> ou big endian.
|> int isIntel(void)
|> {
|> long l = 1 ;
|> return *((char *)(&l)) ;
|> }
Je suis un peu curieux en ce qui concerne le nom. Après
tout, la fonction renvoie la même chose, que ce soit un
processeur Intel ou un VAX.
Ca m'a fait me sentir vieux de voir attriber à Intel plutôt
qu'a DEC cet ordre :-)
Je suis aussi curieux de ce qu'on pourrait faire d'une
telle information. Après tout, il reste beaucoup qu'elle
ne me dit pas. (Que renvoie-t-elle, par exemple, sur un
Unisys 2200 ?)
Aucune idée (successeur des Univac 1100, ça doit aussi être
une machine 36 bits, complément à 1, adressable par mot
non?). Pour un PDP-10 (36 bits, complément à 2, adressable
par mot aussi) ça donnerait vraissemblablement 0 (mais je ne
les ait pas programmé en C) vu la manière dont les char
étaient stockés sur ces machines.
A+
--
Jean-Marc
FAQ de fclc: http://www.isty-info.uvsq.fr/~rumeau/fclc
Site de usenet-fr: http://www.usenet-fr.news.eu.org
|> > Est-il possible avoir un code en C capable de detecter le type de |> > processeur, en de lui forcer l'ecriture ou la lecture d'un fichier |> > binnaire en little ou big endian indifferement ???
|> Tu peux écrire une fonction qui te dit si ta machine est en little |> ou big endian.
|> int isIntel(void) |> { |> long l = 1 ; |> return *((char *)(&l)) ; |> }
Je suis un peu curieux en ce qui concerne le nom. Après tout, la fonction renvoie la même chose, que ce soit un processeur Intel ou un VAX.
Ca m'a fait me sentir vieux de voir attriber à Intel plutôt qu'a DEC cet ordre :-)
Je suis aussi curieux de ce qu'on pourrait faire d'une telle information. Après tout, il reste beaucoup qu'elle ne me dit pas. (Que renvoie-t-elle, par exemple, sur un Unisys 2200 ?)
Aucune idée (successeur des Univac 1100, ça doit aussi être une machine 36 bits, complément à 1, adressable par mot non?). Pour un PDP-10 (36 bits, complément à 2, adressable par mot aussi) ça donnerait vraissemblablement 0 (mais je ne les ait pas programmé en C) vu la manière dont les char étaient stockés sur ces machines.
A+
-- Jean-Marc FAQ de fclc: http://www.isty-info.uvsq.fr/~rumeau/fclc Site de usenet-fr: http://www.usenet-fr.news.eu.org
