Mengen

Mengen sind spezielle Ausdrücke, die eine Sammlung von konstanten Werten zusammenfassen und das Verwalten oder Zuweisen von Datensammlungen erleichtern (z.B. eine Liste von Zahlen und Texten).

Eine Menge steht im Quelltext innerhalb geschweifter Klammern {…}. Wenn als Basis eine Strukturdeklaration zugrunde liegt, können innerhalb einer Menge weitere Untermengen eingebettet sein.

Eine Menge besteht also grundsätzlich aus einer sog. Basismenge und Ggf. weiteren Untermengen. Als Basismenge wird das erste Klammerpaar bezeichnet, in welcher sich die Werte und Ggf. weitere Untermengen befinden. Weiterhin beginnt eine Menge mit einem numerischen Datentyp oder einem Strukturnamen.

Wird eine Menge mit einer Strukturdeklaration eingeleitet, werden die entsprechend in der Struktur angegebenen Datentypen erwartet. Strukturelemente erwarten wiederum eine Untermenge mit passendem Strukturnamen (verschachtelt). Siehe hierzu Beispiel 2.

• Hinweis: Intrinsische Datentypen wie string, MemoryBlock, Graphics, dptr, eptr, sptr sind nicht erlaubt.

Folgend eine Basismenge in welcher alle Werte als Typ „byte“ betrachtet werden. Dies betrifft auch die Zeichenkette die in diesem Fall eine Sammlung von einzelnen Bytes - den Buchstaben - darstellt.

byte{ 1, 2, 3, "hallo" } 

Folgend eine Basismenge in welcher alle Werte als Typ „uint24“ betrachtet werden

uint24{ 1, 2, 3 } 

Folgend eine Basismenge in welcher die Werte von verschiedenem Typ sind, der Aufbau „was ist was“ wird durch eine Strukturdeklaration definiert.

struct mystruct
  byte myarray(2)
  word value1
  long value2
endstruct
 
mystruct{ { 1, 2 ,3 }, 4, 5 }
'              ^       ^  ^
'              |       |  |
'              |       |  +- mystruct.value2
'              |       +- mystruct.value1
'              +- mystruct.myarray

Anwendung finden Mengen z.B. beim definieren von Datensätzen im Programmspeicher (flash) oder der Zuweisung von Datensätzen auf einen Speicherbereich im Arbeitsspeicher (sram) oder Eeprom (eram).

Mithilfe von Mengen können Daten/Werte die sonst einzeln vorliegen für den Menschen leichter lesbar im Quelltext zusammengefasst werden. Weiterhin ermöglichen sie erst die Zuweisung von ganzen Datensätzen mit Elementen verschiedener Typen „in einem Rutsch“ auf Speicherbereiche, z.B. einem Array.

struct mystruct
  byte   myarray(2)
  word   level
  string text[14]
endstruct
 
data table
  mystruct{ { 1, 2 ,3 }, 4, "hallo" } 'Text wird auf die in der Strukturdeklaration 
  mystruct{ { 5, 6 ,7 }, 8, "ballo" } 'definierten Länge von "text" mit Leerzeichen aufgefüllt.
enddata

Obiges Beispiel ist dasselbe wie die Einzelangabe mit .db, .dw usw.:

data table
  .db 1, 2, 3
  .dw 4
  .db "hallo         "
  .db 5, 6, 7
  .dw 8
  .db "ballo         "
enddata

Basismengen erlauben auch „normale“ Datentypen wie byte, word usw., womit man natürlich in Flash-Datenobjekten nicht viel gewinnt, aber es ist möglich:

data table
  byte{ 1, 2, 3, "hallo" }
  word{ 0x1122, 0xabcd9 }
enddata

Obiges Beispiel ist dasselbe wie die Einzelangabe mit .db, .dw usw.:

data table
  .db 1, 2, 3, "hallo"
  .dw 0x1122, 0xabcd9
enddata

Basismenge mit Struktur und Untermenge mit Struktur.

struct pair
  byte   value1
  byte   value2
endstruct
struct mystruct
  word   level
  string text[14]
  pair   bytepair
endstruct
 
data table
  mystruct{ 1, "hello", pair{ 23, 42 } } 
  mystruct{ 2, "world", pair{ 10, 20 } } 
  '         ^     ^      ^    ^   ^
  '         |     |      |    |   + mystruct.bytepair.value2
  '         |     |      |    + mystruct.bytepair.value1
  '         |     |      +- mystruct.bytepair
  '         |     +- mystruct.text
  '         +- mystruct.level
enddata

Ein Array eines Datentyps ist nichts weiter als aneinandergereihte Speicherzellen die einzeln angesprochen werden können. Sie können also insgesamt auch als ein durchgängiger Speicherblock betrachtet werden.

Folgend ein Beispiel um ein Array in einem Rutsch mit festen Werten zu belegen:

dim a(7) as byte '8 Elemente
a() = byte{ 11, 22, 33, 44, 55, 66, 77, 88 }
'Das Array enthält nach dieser Zuweisung im Element a(0) den Wert 11, im
'Element a(1) den Wert 22 usw.

Hinweis: Aufpassen muss man hier mit der Anzahl der Elemente in der Menge, denn wird die Anzahl des Speicherplatzes vom Array überschritten, werden Ggf. nachfolgende Daten überschrieben. Die Menge hat keinen direkten Bezug zum Array. Aus Sicht der Menge ist es nur ein Speicherplatz.

Es kann auch nur ein Teil belegt werden:

dim a(7) as byte '8 Elemente
a(3) = byte{ 11, 22 }
'Das Array enthält nach dieser Zuweisung im Element a(3) den Wert 11 und im
'Element a(4) den Wert 22

Auch intrinsische Datentypen wie Pointer oder MemoryBlock, welche einen Zeiger auf einen Speicherbereich enthalten, können mit Daten beschrieben werden. Hierbei wird die Zieladresse aus dem Pointer/MemoryBlock/String ausgelesen und das als Speicherziel verwendet. D.h. z.B. bei einem MemoryBlock oder String ist das Ziel der Daten der Speicherblock welcher dem MemoryBlock oder dem String zugewiesen wurde.

Wichtig: Es muss sichergestellt werden, dass dem Pointer, dem MemoryBlock oder String auch tatsächlich ein gültiger Speicherblock oder eine Zieladresse zugewiesen wurde!

dim m as MemoryBlock
m = new MemoryBlock(16) 'Einen Speicherblock anlegen mit 16 Bytes Speicherplatz
if m <> nil then          'Prüfen ob der erzeugte Speicherblock zugewiesen wurde.
  m = byte{ 11, "Hallo" } 'Schreibt den Bytewert 11 und nachfolgend die bytes des Textes in den Speicherblock.
end if
dim p as sptr          'Einen Pointer anlegen
dim buffer(15) as byte 'Einen Speicherbereich mit 16 Bytes anlegen (Array)
 
p = buffer(4).Addr      'Startadresse ab Element buffer(4) zuweisen
p = byte{ 11, "Hallo" }
'Im Array buffer steht nun:
'  buffer(4) = 11
'  buffer(5) = 72  (ASCII-Zeichen "H")
'  buffer(6) = 97  (ASCII-Zeichen "a")
'  buffer(7) = 108 (ASCII-Zeichen "l")
'  buffer(8) = 108 (ASCII-Zeichen "l")
'  buffer(9) = 111 (ASCII-Zeichen "o")