fseek & fseeko64

Version imprimable

07/04/2009, 07h54
uriotcea

fseek & fseeko64

Bonjour,

fseek avec un shift négatif fonctionne trés bien mais fseeko64 avec le même shift négatif déconne completement. Si j'essaye de le faire il m'ecrit un fichier de 4Gb avant de sortir de la fonction !!
Quelqu'un a-t-il déjà remarqué ca?
Merci d'avance
07/04/2009, 08h16
nicolas.sitbon

A tout hasard, tu ne serais pas sur une archi 64 bits?
07/04/2009, 12h43
Médinoc

Vérifie que ton shift négatif est bien sur 64 bits dès le début.
Car là, je flaire la mauvaise promotion de (long)-1 en (long long)-1 (passage non-voulu par unsigned long)...
07/04/2009, 19h38
uriotcea

archi 64 ou 32 c'est pareil,

Pas béte, je vais essayer de passer le -1 en 64 bits directement

Merci de vos suggestions
07/04/2009, 20h34
nicolas.sitbon

Citation:

Envoyé par uriotcea

archi 64 ou 32 c'est pareil,

Si tu le dis...
08/04/2009, 07h41
uriotcea

Je le dis et je l'ai testé, sur les 2 archi j'ai le même comportement anormal
08/04/2009, 10h10
Médinoc

On peut voir le code?

Voici un peu de code. L'un fonctionne l'autre non, sur machine 32 ou 64 bytes.

Ne fonctionne pas.
Code:

1 2 3 4 5 f0=fopen64(fich,"rb"); ... long long int dd = -sizeof(int)-3*sizeof(double); fseeko64(f0,dd,SEEK_CUR);
Focntionne, à priori c'est équivalent, sauf erreurr de ma part, au code ci-dessus.
Code:

1 2 3 4 5 6 f0=fopen64(fich,"rb"); ... long long int dd = ftello64(f0); dd=dd-sizeof(int)-3*sizeof(double); fseeko64(f0,dd,SEEK_SET);

sizeof(int) étant unsigned, il y a un risque (je ne connais pas assez bien les règles de promotion pour les calculs).
Essaie plutôt un truc du genre:
Code:

1 2 3 4 5 6 7 f0=fopen64(fich,"rb"); ... off64_t sizeOfInt = sizeof(int); /*garanti signé et 64 bits*/ off64_t sizeOfDouble = sizeof(double); off64_t dd = -sizeOfInt - 3*sizeOfDouble; assert(off64_t < 0); fseeko64(f0, dd, SEEK_CUR);
Ou au moins, rajoute l'assertion avant ton appel à fseeko64().

08/04/2009, 12h56
uriotcea

Tu as la solution.
bravo.
Je ne suis pas certain d'avoir bien compris la différence entre ta méthode et la mienne, mais c'est clair ca marche.
08/04/2009, 13h24
Médinoc

Edit: Le post suivant contient les valeurs à jour

J'ai modifié mon programme pour faire un test supplémentaire. Les résultats sont édifiants:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
void TestSize2(void) /*ligne 27*/
{
	{
		unsigned short myu16 = 1;
		signed long mys32 = -myu16;
		signed long oths32 = 0;
		oths32 -= myu16;
		printf("Valeurs 32 bits apres soustraction d'un nombre 16 bits sans signe: %ld, %ld.\n", mys32, oths32);
	}
 
	{
		unsigned long myu32 = 1;
		signed long mys32 = -myu32; /* ligne 39 ici */
		signed long oths32 = 0;
		oths32 -= myu32;
		printf("Valeurs 32 bits apres soustraction d'un nombre 32 bits sans signe: %ld, %ld.\n", mys32, oths32);
	}
 
	{
		unsigned long myu32 = 1;
		signed long long mys64 = -myu32; /* ligne 47 ici */
		signed long long oths64 = 0;
		oths64 -= myu32;
		printf("Valeurs 64 bits apres soustraction d'un nombre 32 bits sans signe: %lld, %lld.\n", mys64, oths64);
	}
 
	{
		signed long mys32 = -sizeof(int); /* ligne 54 ici */
		signed long oths32 = 0;
		signed long long mys64 = -sizeof(int); /* ligne 56 ici */
		signed long long oths64 = 0;
		oths32 -= sizeof(int);
		oths64 -= sizeof(int);
		printf("Valeurs 32 bits apres soustraction d'un sizeof: %ld, %ld.\n", mys32, oths32);
		printf("Valeurs 64 bits apres soustraction d'un sizeof: %lld, %lld.\n", mys64, oths64);
	}
}

Voici la sortie de Visual:

Code:

1
2
3
4
testsize.c(39) : warning C4146: unary minus operator applied to unsigned type, result still unsigned
testsize.c(47) : warning C4146: unary minus operator applied to unsigned type, result still unsigned
testsize.c(54) : warning C4146: unary minus operator applied to unsigned type, result still unsigned
testsize.c(56) : warning C4146: unary minus operator applied to unsigned type, result still unsigned

Et la sortie du programme:

Code:

1
2
3
4
5
Valeurs 32 bits apres soustraction d'un nombre 16 bits sans signe: -1, -1.
Valeurs 32 bits apres soustraction d'un nombre 32 bits sans signe: -1, -1.
Valeurs 64 bits apres soustraction d'un nombre 32 bits sans signe: 4294967295, -1.
Valeurs 32 bits apres soustraction d'un sizeof: -4, -4.
Valeurs 64 bits apres soustraction d'un sizeof: 4294967292, -4.

Il est intéressant de constater que ça ne se passe pas avec des short, mais que ça agit sur les long (et leur promotion en 64 bits). Sans doute est-ce dû à la taille du type int sur ce système (32 bits, la même qu'un long).

08/04/2009, 13h34
Médinoc
Ce qui nous donne une grille des résultats du - unaire sur des nombres non-signés:
- '-' sur unsigned short --> signed int
- '-' sur unsigned int --> unsigned int
- '-' sur unsigned long --> unsigned long
- '-' sur unsigned long long --> unsigned long long
08/04/2009, 13h46
nicolas.sitbon
Citation:
Envoyé par uriotcea

Ne fonctionne pas.

Code:

1 2 3 4 5 f0=fopen64(fich,"rb"); ... long long int dd = -sizeof(int)-3*sizeof(double); fseeko64(f0,dd,SEEK_CUR);

Focntionne, à priori c'est équivalent, sauf erreurr de ma part, au code ci-dessus.

Code:

1 2 3 4 5 6 f0=fopen64(fich,"rb"); ... long long int dd = ftello64(f0); dd=dd-sizeof(int)-3*sizeof(double); fseeko64(f0,dd,SEEK_SET);
Plusieurs choses, déjà c'est une mauvaise habitude que d'appeller les fonctions suffixés par 64.
Ensuite, les 2 codes précédents ne sont pas du tout équivalents, comme le fait remarqué médinoc, il y a des soucis de promotion:

Code:

long long int dd = -sizeof(int)-3*sizeof(double);

sizeof(int) vaut 4 (mettons que nous somme sur une archi ILP32)
-sizeof(int) vaut 4 294 967 292 (principe de la réduction modulo)
sizeof(double) vaut 8
total = 4 294 967 292 - 3 * 8 = 4294967268

deuxième cas :

Code:

dd=dd-sizeof(int)-3*sizeof(double);

mettons que dd vaut 50 au départ
total = 50 - 4 - 3 * 8 = 22

Dans le premier cas, on applique un opérateur unaire sur sizeof(int) qui conserve son type soit size_t, on prend sa valeur soit 4, que l'on rend négative soit -4, auquel on apllique la règle du modulo : -4 + (INT_MAX + 1)

Dans le second cas, c'est différent, sizeof(int) est soustrait à un long long, il est donc lui même promu en long long, ça valeur ne change pas.
08/04/2009, 13h49
Médinoc

Citation:

Envoyé par nicolas.sitbon

c'est une mauvaise habitude que d'appeller les fonctions suffixés par 64.

Je proteste.

Je sais que c'est non-portable, mais sur un système où ça marche, ça n'est pas "mauvais". De plus, sur un système 32 bits, c'est souvent le seul moyen d'opérer sur des fichiers de taille supérieure à 4Go (ou même 2Go quand on ne gère pas correctement la taille).
08/04/2009, 13h49
uriotcea

Juste une remarque, si tu es sous windows %lld n'est pas capable d'afficher correctement des 64b mais I64i% oui
Enfin je parle de gcc ici
Ensuite ces fonctions 64 sont justement faites pour assuré la portabilité descedente de 64 vers 32 et foncionnent aussi bien sous windows que sur linux
Que demander de plus !
08/04/2009, 13h53
Médinoc

Ça dépend si tu utilises une C Run-Time Library (CRT) obsolète ou non.
La CRT de Visual 2005 affiche parfaitement les %lld. Celle de Visual 6 ne le fait pas, vu qu'elle date d'avant.
Et MinGW utilise la CRT de Visual 6. C'est de leur faute.
08/04/2009, 13h56
uriotcea

Ok merci pour l'info, j'espere qu'il vont shifter parce que c'est plutot ennuyeux d'avoir à ecrire les choses différent suivant le syteme