Nächste Seite: Erlaubte Operationen Aufwärts: Ausdrücke Vorherige Seite: Ausdrücke

### Faktoren

Faktoren sind die elementaren Bestandteile eines Ausdrucks. Diese können sein:

Geklammerte Ausdrücke
  . Die Klammerung erfolgt in diesem Assembler durch geschweifte (,,{`` und ,,}``), und nicht durch runde Klammern! Eine ,,normale`` Klammerung ist wegen der erweiterten Adressierungsarten des 68020 und höherer Prozessoren syntaktisch unmöglich (`MOVE.L (2+2),A6` wäre zweideutig, indirekt oder absolut).
Ganze Zahlen
  können binär, oktal, dezimal, hexadezimal oder als einzelnes Zeichen angegeben werden. Gleitkommazahlen sind nicht erlaubt.
  - Binärzahlen werden durch ,,`%``` eingeleitet.
  - Oktalzahlen beginnen mit ,,`@```.
  - Dezimalzahlen haben keinen Präfix.
  - Hexadezimalzahlen sind durch ein führendes ,,`$``` gekennzeichnet.
  - Zeichen sind durch einfache oder doppelte Hochkommata eingeschlossene Einzel-Zeichen. Ihr Wert ergibt sich aus dem Amiga-Zeichensatz.
  Die Schreibweisen ,,``%`1000010```, ,,``@`102```, ,,`66```, ,,`$42``` und ,,``"`B`"```` repräsentieren dieselbe Zahl 66.
Zeichenketten
  sind nur bei der Instruktion ,,`DC.B``` erlaubt.
Label
  , die im Assemblertext definiert sind oder noch definiert werden.
Modula-2-Konstanten
  , die im aktuellen Sichtbarkeitsbereich liegen:
  - Ganzzahlige und `CHAR`-Konstanten.
  - Zeichenketten des eigenen Moduls. Diese werden PC-relativ adressiert.
  - Zeichenketten eines implementationslosen Moduls sind ebenfalls PC-relativ, da sie in den Konstanten-Bereich des eigenen Moduls aufgenommen werden, z.B. `DosD.dosName`.
  - Zeichenketten eines fremdem Moduls mit Implementation werden absolut lang adressiert. Hier ist zu beachten, dass Library-Moduln neuerdings ein Objektfile besitzen. So ist etwa die Zeichenkette ,,`DosL.dosName``` lang zu adressieren.
Record-Bezeichner
  können benutzt werden, um die Offsets bestimmter Felder innerhalb eines `RECORD`s anzugeben,

  > ,,`DosD.Process.task.sigWait```

  ergibt beispielsweise den absoluten Wert 22. Um nun ein Feld einer `RECORD`-Variablen anzusprechen, schreibt man ebenso einfach

  > ,,`myProcess.task.sigWait(A4)```,

  vorausgesetzt, `myProcess` ist eine -Variable.
-Variablen
  müssen 16Bit-relativ zu einem Adressregister adressiert werden. In M2Amiga ist dies immer A4. Nachdem ein anderes Register mit dem Inhalt von A4 geladen wurde, darf es natürlich auch relativ zu diesem Register sein. Dies gilt sowohl für moduleigene wie auch für importierte Variablen. Auch wenn der Offset einer Variablen bekannt ist, darf keinesfalls einfach ,,`10(A4)``` geschrieben werden, da hier sehr wichtige Information verloren geht. Die Folge wäre, dass vom Linker falscher Code erzeugt würde!
-Variablen
  werden absolut adressiert. Der Programmierer muss wissen, welchen Modus ( oder ) eine Variable hat; der Assembler erzeugt bei falscher Benutzung eine Fehlermeldung.
Lokale Variablen und Parameter
  werden im allgemeinen relativ zum Register A5 adressiert. Der Wert ist im Gegensatz zu den -Variablen eine absolute Zahl, die den Offset zum Basisregister A5 der zugehörigen Prozedur in einer normalen Laufzeitumgebung -- also mit Eingangs- und Ausgangscode -- angibt.

  Eine Besonderheit stellt hier die Adressierung von offenen Feldern dar. Angenommen `arr1` sei ein Parameter vom Typ `ARRAY OF typename`, so bezeichnet `arr1` die Adresse des Feldes und der `HIGH`-Wert (Anzahl der Elemente-1) liegt in . Dies gilt sowohl für Referenz- wie auch für Werte-Parameter!

  Falls die Variable oder der Parameter in einer äusseren Prozedur definiert ist, muss man sich zunächst den Inhalt des Registers A5 der zugehörigen Prozedur beschaffen! Dazu muss je Level der statische Link aus 8(A5) geladen werden. Beispiel:

Moduln
  können nur dann adressiert werden, wenn es sich um Schnittstellen-Moduln handelt. Hier bezeichnet der Name des Moduls eine -Variable, die wie oben relativ zu A4 adressiert werden muss. Der Inhalt ist der Zeiger auf die Library. Beispiel:

Prozeduren
  werden beim Aufruf immer `d16(PC)` adressiert. Um es einheitlich zu halten, sollte man Prozeduren des eigenen Moduls via `BSR Proc` aufrufen, modulfremde Prozeduren mittels `JSR Proc(PC)`. Möchte man jedoch die Adresse einer modulfremden Prozedur ansprechen, muss absolut adressiert werden, beispielsweise durch `LEA Proc, A0`. Dies ist durch die Methoden des Linkers bedingt.
CODE-Prozeduren
  ergeben den absoluten Offset, so dass man z.B. einfach `JSR Forbid(A6)` schreiben kann.
XREF-Bezeichner
  erzeugen je nach Art der Benutzung eine 16- oder 32Bit Referenz (`REF16`, `DREF16`, `REF32`) für den Linker.
,,`*```
  bezeichnet den aktuellen Programmzähler. Dieser Faktor ist allerdings nur bei ,,`DC.x``` erlaubt, um Differenzen zwischen Labeln bilden zu können! Die andere denkbare Nutzung, wie z.B. in ,,`BRA `*`+4```, ist in diesem Assembler nicht möglich, da die nachträgliche Optimierung durch den Compiler diesen Sprung ins ,,Nirwana``2.22 schicken könnte! Man sollte also strikt mit Labeln arbeiten.

Nächste Seite: Erlaubte Operationen Aufwärts: Ausdrücke Vorherige Seite: Ausdrücke