Discussion :

[Morvan Mikael]

Bonjour,

Je réalise le portage d'une bibliothèque Delphi vers Php et je bute sur un problème: l'opérateur "shr"

Entre l'opérateur Delphi shr et l'opérateur php: ">>" il y une différence
Par exemple j'ai une opération -271733879 shr 2 qui devient 1005808354 en Delphi
et la même chose en php (-271733879 >> 2 ) donne -67....

Quelle peut être la solution à ce problème ?

Merci de votre aide, je patine un peut la...

[Linkin]

-271733879 shr 2 me donne -67933470
une variable := -271733879; // LongInt ou Integer
unevariable shr 2 me donne 1005808354

Le pourquoi, je ne peux pas te répondre.

Edit: le premier ajoute des bits à 1 lors du décalage, le second des bits à 0. Par contre toujours pas de solution;

[Sub0]

Peut-être que ce sujet répond à cette question :

c'est simple, c'est le même chose que pour shl et shr sauf que les bits qui sont expulsés sont remis de l'autre coté. c'est un peu comme une rotation de bits.

Par contre, pour la solution je ne vois pas, faudrait creuser la question, déjà afficher et comparer ces valeurs en binaire, peut-être utiliser la division et multiplication plutôt que le décalage.

[Morvan Mikael]

Merci,

Je pense avoir trouvé mais sans comprendre pourquoi

Code :

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

1
2
3
4
 
function shr($a, $b){ // unsigned shift right
		return (2147483648 & $a)?((($a>>1) & ~2147483648)|0x40000000)>>($b-1):($a>>$b);
	}

Par contre j'ai toujours des problèmes de contrôle de débordement en Delphi que je ne retrouve pas en PHP. Je n'ai donc toujours pas les mêmes valeurs entre Php et Delphi

Je vais aller voir dans les forums Php pour voir ça

Merci

[Paul TOTH]

c'est une question de signe

le shr de Delphi perd le signe

donc (-1 shr 1) donne MaxInt

en binaire, "-1" c'est tout les bits allumés.
shr 1 va décaler les bits d'un cran à droite...en introduisant un 0 à gauche.
du coup tu te retrouves avec un nombre positif (bit de gauche à 0) dont tous les autres bits sont à 1 ... soit le plus grand entier signé positif = MaxInt

le ">>" de PHP conserve le signe, du coup c'est un bit à 1 qui est introduit à gauche.

d'où le "unsigned" shift

Code php :

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
 
function shr($a, $b){ // unsigned shift right
// le nombre est-il négatif ?
 return (2147483648 & $a) ? 
// 1) signé, traitement spécial
  (
 (  
  // shift signé de 1 bit
   ($a>>1) 
  // on supprime le signe
   & ~2147483648)
 // et on le remet un bit plus bas
  |0x40000000
  )
// on peut continuer avec le nombre maintenant non signé pour les autres bits
 >>($b-1)
// 2) non signé, faire un simple shift
 : ($a>>$b);
}

bon c'est un tordu celui qui tape "2147483648" et "2147483647" !
moi je prend toujours des notations hexa 0x80000000 ou 0x7FFFFFFFF

[Morvan Mikael]

Merci pour ta réponse Paul,

J'ai compris en fait l'origine du problème et effectivement Php et Delphi ne gère pas la même implémentation pour les Shr et Shl. J'ai donc trouvé sur le net de nouvelles fonctions qui permettent de refaire la même chose.
Pour compléter j'ai également utilisé une addition préservant les 32 bits.

En résumé, pour le portage de ma bibliothèque de Crypto de Delphi vers Php, il faut absoluement prendre en compte la largeur des opérateurs (32 bits dans mon cas).

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
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
 
           function shr32 ($x, $bits)
	{
	    if ($bits==0) return $x;
	    if ($bits==32) return 0;
	    $y = ($x & 0x7FFFFFFF) >> $bits;
	    if (0x80000000 & $x) {
	        $y |= (1<<(31-$bits));    
	    }
	    return $y;
	}
 
	function shl32 ($x, $bits)
	{
	    if ($bits==0) return $x;
	    if ($bits==32) return 0;
	    $mask = (1<<(32-$bits)) - 1;
	    return (($x & $mask) << $bits) & 0xFFFFFFFF;
	}
 
	function or32 ($x, $y)
	{
	    return ($x | $y) & 0xFFFFFFFF;
	}
 
	function xor32($x, $y) {
		return ($x ^ $y) & 0xFFFFFFFF;
	}
 
	function add32 ($x, $y)
	{
 
	    $x = $x & 0xFFFFFFFF;
	    $y = $y & 0xFFFFFFFF;
 
	    $total = 0;
	    $carry = 0;
	    for ($i=0; $i<4; $i++) {
	        $byte_x = getbyte32($x, $i);
	        $byte_y = getbyte32($y, $i);
	        $sum = $byte_x + $byte_y;
 
	        $result = $sum & 0xFF;
	        $carryforward = shr32($sum, 8); 
 
	        $sum = $result + $carry;
	        $result = $sum & 0xFF;
	        $carry = $carryforward + shr32($sum, 8); 
 
	        $total = or32(shl32($result, $i*8), $total); 
	    }
 
	    return $total;
	}