Problem: Keine Integers in JavaCard. ToDo: Rechnen mit Bytes und Shorts

Transkript

1 Kapitel 6: Arithmetik in JavaCard Problem: Keine Integers in JavaCard ToDo: Rechnen mit Bytes und Shorts Java SmartCards, Kap. 6 (1/20)

2 Hex-Notation 1 Byte = 8 Bit, b 7 b 6 b 5 b 4 b 3 b 2 b 1 b }{{} 1110 }{{} = = 94 5 E = 0x5E = = 94 Hex: 0...9, 10 = A, 11 = B, 12 = C, 13 = D, 14 = E, 15 = F Java SmartCards, Kap. 6 (2/20)

3 Wertebereiche in Java Typ Länge Minimaler Wert Maximaler Wert byte 8 Bit short 16 Bit int 32 Bit long 64 Bit Java SmartCards, Kap. 6 (3/20)

4 Arithmetik in Java: Java Language Specification (Integer Operations): If an integer other than a shift operator has at least one operand of type long, then the operation is carried out using 64-bit precision, and the result of the numerical operator is of type long. If the other operand is not long, it is first widened ( 5.1.4) to type long by numeric promotion ( 5.6). Otherwise, the operation is carried out using 32-bit precision, and the result of the numerical operator is of type int. If either operand is not an int, it is first widened to type int by numeric promotion. Java SmartCards, Kap. 6 (4/20)

5 Arithmetik in Java: Argumente werden automatisch nach int konvertiert Berechnung mit Integers Ergebnis ist int Kein Check auf Over-/Underflow short x, y;...short z = (short)(x * y); (Cast notwendig) = (Overflow) (Bem.: Ein Argument long: Berechnung/Ergebnis long, analog für float, double) Java SmartCards, Kap. 6 (5/20)

6 Arithmetik in Java: Automatische Konvertierung byte short int Umgekehrt ist expliziter Cast notwendig! Cast: überzählige Bits abschneiden Ergebnis von Arithmetikoperationen ist immer vom Typ int. Arithmetikoperationen: +, -, *, /, % und Bitoperationen: & (And), (Or), ^ (Xor), ~ (Komplement) links-shift <<, rechts-shift >> (mit Vorzeichen), >>> (mit Nullen) Negative Zahlen: 2er-Komplement Java SmartCards, Kap. 6 (6/20)

7 Arithmetik in Java: Java Language Specification (Widening Primitive Conversion): A widening conversion of a signed integer value to an integral type T simply sign-extends the two s-complement representation of the integer value to fill the wider format. Java Language Specification (Narrowing Primitive Conversion): A narrowing conversion of a signed integer to an integral type T simply discards all but the n lowest bits, where n is the number of bits used to represent type T. In addition to a possible loss of information about the magnitude of the numeric value, this may cause the sign of the resulting value to differ from the sign of the input value. Java SmartCards, Kap. 6 (7/20)

8 2er-Komplement: 1. Schritt: bilde Bitdarstellung des Betrags Schritt: bitweise Invertierung Schritt: addiere = = -34 = (byte) (short) (int) (byte) (short) (int) Java SmartCards, Kap. 6 (8/20)

9 Eigenschaften Führendes Bit ist Vorzeichen: 0 ˆ= positive, 1 ˆ= negative Zahl größte Byte-Zahl: = 0x7F = 127 kleinste Byte-Zahl: = 0x80 = -128 Cast schneidet obere Bits ab: Rest: 5 % 3 = 2, -5 % 3 = -2, 5 % -3 = 2, -5 % -3 = -2 int i; 0 i i % (byte)i = i % i 127 < i % 256 (byte)i = (i % 256) 256 i < 0 i % 256 < 128 (byte)i = (i % 256) i < i % 256 (byte)i = i % 256 Java SmartCards, Kap. 6 (9/20)

10 6 weitere Bemerkungen dazu: 1. Arithmetik ist vom Typ int: byte b = (byte)(x + y); (x, y Bytes) byte b = (byte)(x & 0x7F); (x Byte) Beide Argumente werden in Integers umgewandelt die Rechenoperation wird auf Integers ausgeführt das Ergebnis ist ein Integer Cast notwendig. (Auch wenn Ergebnis in ein Byte passt.) 2. Integer Literale: Konstanten sind immer vom Typ Integer byte b = 0x20; (narrowing primitive conversion) byte b = (byte)0xa0; (kein signed Byte) f((short)0) (bei Methoden keine narrowing primitive conversion) Java SmartCards, Kap. 6 (10/20)

11 3. Casts: A0 = führendes 1-Bit byte int: A0 FF FF FF A0 int byte: A0 A0 4. Signed vs. Unsigned Bytes: (int)0xa0 = 160, aber (int)(byte)0xa0 = 96. unsigned byte int: (b & 0xFF) da (int)((byte)0xa0 & 0xFF) = int High-Byte, Low-Byte: (i >> 8) & 0xFF und i & 0xFF (vgl. setshort) High-Byte, Low-Byte int: (b1 << 8) (b2 & 0xFF) (vgl. getshort) 6. (short)(-1 >>> 15) == -1 Java SmartCards, Kap. 6 (11/20)

12 Short- vs. Integer-Arithmetik 1. Beispiel: short x1 = 20000, x2 = (short)((x1 * 5) / 10); Integer-Arithmetik: x2 = Short-Arithmetik: x2 = Beispiel: short x1 = 20000, x2 = 30000, x3 = (short)((x1 + x2) - x2); Integer-Arithmetik: x3 = Short-Arithmetik: x3 = Beispiel: short x1 = 20000, x2 = 30000; boolean res = (x1 < x1 + x2); Integer-Arithmetik: res = true; Short-Arithmetik: res = false; Java SmartCards, Kap. 6 (12/20)

13 Der cap-converter: prüft, dass kein int, long,...benutzt wird. prüft, dass short-arithmetik = int-arithmetik Rechengesetze Beispiele: 1. (short)((x * y) - z) Ok 2. x + y < z Fehler! 3. (x + y) / 1000 Fehler! Java SmartCards, Kap. 6 (13/20)

14 Prinzip short-arithmetik = int-arithmetik, wenn das Ergebnis einer Operation (sofort) nach (short) oder (byte) gecastet wird: (short)(x y) 2. die Operation innerhalb eines Casts stattfindet und bestimmte Rechenregeln gelten: (short)(a 1 ((b 2 c) 3 d)) 3. das Ergebnis von der Größe her in ein short passt: byte b, c; < b * (x % c) < Java SmartCards, Kap. 6 (14/20)

15 Rechengesetze (1): s, t: bel. Ausdrücke mit Ergebnistype int, z. B. s = (x * y) * z 1. Unäres Minus: (short)(- s) = (short)(- (short)s) 2. Addition: (short)(s + t) = (short)((short)s + t) 3. Subtraktion: (short)(s - t) = (short)(s - (short)t) 4. Multiplikation: (short)(s * t) = (short)((short)s * t) und sämtliche Varianten. Bem.: 1. wird vom cap converter nicht akzeptiert. Java SmartCards, Kap. 6 (15/20)

16 Rechengesetze (2): 1. Komplement: (short)( ~ s) = (short)( ~ (short)s) 2. Bitweises Und: (short)(s & t) = (short)((short)s & t) 3. Bitweises Oder: (short)(s t) = (short)((short)s t) 4. Bitweises Xor: (short)(s ^ t) = (short)((short)s ^ t) 5. Links-Shift: (short)(s << n) = (short)((short)s << n) und sämtliche Varianten. Java SmartCards, Kap. 6 (16/20)

17 Rechengesetze (3): Im Allgemeinen (auch für Varianten): 1. (short)(s / t) (short)((short)s / (short)t) Beispiel: s = 2 16, t = (short)(s % t) (short)((short)s % (short)t) Beispiel: s = , t = (short)(s >> n) (short)((short)s >> n) Beispiel: s = 2 15, n = 1 4. (short)(s >>> n) (short)((short)s >>> n) Beispiel: s = 2 15, n = 1 gilt natürlich, wenn s und t in ein short passen. Java SmartCards, Kap. 6 (17/20)

18 Rechengesetze (4): Im Allgemeinen (auch für Varianten): 1. s < t (short)s < (short)t 2. (short)s == (short)t s == t aber natürlich s == t (short)s == (short)t (short)(x + y) == z Cast ist notwendig! gilt natürlich, wenn s und t in ein short passen. Java SmartCards, Kap. 6 (18/20)

19 Rechengesetze (5):...gilt, wenn s und t in ein short passen? 1. short x,y,z x & y passt Ok! (x & y) == z kein Cast notwendig. Ebenso für, ^, ~, >>, >>> 2. short x,y,z x % y passt Ok! (x % y) == z kein Cast notwendig. Ebenso für / 3. byte x,y x + y, x passt Ok! (x + y) == z kein Cast notwendig. Ebenso für -, * 4. byte x,y,z x + y + z, x passt Fehler! Java SmartCards, Kap. 6 (19/20)

20 Spezielle Konstrukte: 1. Bei Compound assignment impliziter cast: short x; x += y + z; ok, x = (short)(x + (y + z)) x /= y + z; nicht ok, x = (short)(x / (y + z)) 2. Bei Shift wird 2. Argument n implizit zu (n & 31): x >> n x >> (n & 31) Java SmartCards, Kap. 6 (20/20)