Feldaggregate in Ada 83 and Ada 95

Feldaggregate

Christoph Karl Walter Grein

Liebe Lady Ada,

warum darf ich nicht folgendes schreiben:

type A is array (Integer range <>) of Integer;

X: A (-2..+2) := (-2 => 0, others => 1);

wo doch

X := (0, others => 1);

legal ist?

Ein Ratsuchender

Lieber Ratsuchender,

wie ich sehe, bist du noch meinem guten alten Freund von 1983, M. Jean Ichbiah, hörig – im Grunde musst du also ihn fragen. Darf ich dich einladen, statt dessen von jetzt an meinem neuen Freund von 1995, Mr Tucker Taft, zu Willen zu sein? ¹

Vielleicht allerdings gereichen dir ein paar Zeilen zur Erleuchtung? Folgende Zuweisungen sind alle äquivalent:

X := (0, 1, 1, 1, 1);
X := (0, others => 1);
X := (-2 => 0, -1 .. +2 => 1);

Das erste Aggregat erhält seine Grenzen aus der Typdefinition (der Index der ersten Komponente ist gleich dem ersten Indexwert, hier also Integer'First, die Grenzen gleiten bei der Zuweisung), das zweite aus dem Zusammenhang (also X'First für die erste Komponente), beim dritten sind sie explizit angegeben.

Doch ist auch folgendes erlaubt:

X := (-2 => 1, -3 => 0, -1 .. 1 => 1);
X := (-2 => 1, -3 => 0, -1 .. 2 => 1);

Im ersten Fall stimmt die Länge, die Grenzen gleiten wieder bei der Zuweisung – das Ergebnis ist dasselbe wie oben. Im zweiten Fall stimmt jedoch die Länge nicht, die Zuweisung ist tatsächlich aber legal (das heisst, sie muss übersetzt werden; der Compiler darf allerdings, wenn er mag, eine Warnung ausgeben), nur muss sie bei der Ausführung Constraint_Error auslösen.

Wenn du jetzt also, mein lieber Ratsuchender, M. Ichbiah sagen kannst, welche Grenzen dein Aggregat

(-2 => 0, others => 1)

haben soll, magst du ihn wohl schelten.

Mr Taft wird dir dann erläutern, das sei doch ganz einfach – Aggregate mit others gleiten nie ².

Womit dann folgende Aggregate in Ada95 korrekt sind:

(-2 => 0, others => 1)
(-1 => 0, others => 1)

mit denselben Ergebnissen wie

(0, 1, 1, 1, 1)
(1, 0, 1, 1, 1)

wohingegen

(-3 => 0, others => 1)

Constraint_Error auslöst wegen unpassender unterer Grenze.

Zum Abschluss magst du vielleicht selbst noch einige Zuweisungen für Ada83 und Ada95 untersuchen und feststellen, welche der Anweisungen illegal sind (d.h. vom Compiler zurückgewiesen werden müssen) und warum, welche gültig sind (das heißt übersetzt werden), aber Constraint_Error auslösen, und welche anstandslos ausgeführt werden?

Deine Lady Ada

¹ Jean Ichbiah steht für die Regeln in Ada83, Tucker Taft für die in Ada95.
² Dies ist eine neue Regel in Ada95, die das Eingangsproblem löst.

declare

  -- Der Elementtyp ist irrelevant.

  type T is array (Integer range <>) of …;

  A: array (1..3) of …;
  B: T (1..3);

begin

  A := (1 => x, 2 .. 3 => y);

  A := (1 => x, others => y);
  B := (1 => x, others => y);

  A := (0 => x, 1 .. 2 => y);
  B := (0 => x, 1 .. 2 => y);

  A        := (3 => x, others => y);
  A (1..2) := (3 => x, others => y);

  A        := (1 => x, 2 => y);
  A (1..2) := (2 => x, 3 => y);
  A (1..2) := (1 => x, others => y);
  A (1..2) := (2 => x, others => y);

  A        := (x, others => y);
  A (1..2) := (x, others => y);

  A := A (2..3) & A (1);
  B := B (2..3) & B (1);

end;