Bascom - Overload bei Funktionen

[Manfred S. (Firma: Manfred) (xfred343)]

Hallo,

hab gerade folgendes Problem in Bascom:

dim lngReadPointer as long
dim lngWritePointer as long
dim lngReadPointerBytes(4) as byte at lngreadPointer overlay
dim lngWritePointerBytes(4) as byte at lngWritePointer overlay

declare sub Test(byref lngPointer as long)
do
  ...
  call test(lngReadPointer)
  ...
  call test(lngWritePointer)
  ...
loop


sub Test(byref lngPointer as long)
'hier möchte ich auf Byte 1-4 zugreifen
'wie kann ich hier eine Overlay-Variable definieren?
'es kann ja Read- oder Writepointer sein
end sub

Wer weiß da mehr?

Danke

[mue-c (Gast)]

Overlay kannst du in der Sub nicht nutzen.
Aber du kannst das Array übergeben anstelle der Long Variablen.

[Manfred S. (Firma: Manfred) (xfred343)]

Hab ich so befürchtet... ist aber "traurig", dass das nicht anders geht
oder gibts doch eine andere Idee


dim lngReadPointer as long
dim lngWritePointer as long
dim lngReadPointerBytes(4) as byte at lngreadPointer overlay
dim lngWritePointerBytes(4) as byte at lngWritePointer overlay

declare sub Test(byref arrBytes as byte)
do
  ...
  call test(lngReadPointerBytes(1))
  ...
  call test(lngWritePointerBytes(1))
  ...
loop


sub Test(byref arrBytes as byte)
print arrBytes(1)
print arrBytes(2)
..
'hier möchte ich auf Byte 1-4 zugreifen
'wie kann ich hier eine Overlay-Variable definieren?
'es kann ja Read- oder Writepointer sein
end sub

[mue-c (Gast)]

Warum gefällt dir das nicht?
Du willst auf die Bytes zugreifen und übergibst dazu die Bytes. Das 
Overlay hast du global.

[xfred343 (Gast)]

hi,

das ist es ja was mich so stoert, wenn ich global 100 Variablen habe, 
muss ich 100mal die overlays deklarieren, sinnvoller wäre es, wenn ich 
in der Subroutine den Overlay auf die Variable definiere, vielleicht 
geht es Irgendwie mit varptr und Zugriff auf den Speicherbereich

[Karl H. (kbuchegg)]

xfred343 schrieb:
> hi,
>
> das ist es ja was mich so stoert, wenn ich global 100 Variablen habe,
> muss ich 100mal die overlays deklarieren, sinnvoller wäre es, wenn ich
> in der Subroutine den Overlay auf die Variable definiere, vielleicht
> geht es Irgendwie mit varptr und Zugriff auf den Speicherbereich

Na ja.
Du brauchst nicht unbedingt 100 Overlays, sondern nur eines.
Dem weist du den fraglichen Wert zu und holst ihn dir Byteweise wieder 
ab.

BASCOM hat eben auch seine Grenzen. Bei eigenen Datentypen ist Ende der 
Fahnenstange.

[Manfred S. (Firma: Manfred) (xfred343)]

Danke für die Antworten, jetzt dachte ich mir, vielleicht die Overlay in 
die Funktionen zu verlegen - das wird aber recht gemein...
Folgendes ist syntaktisch korrekt und kann problemlos im Bascom-Emulator 
gestartet werden.

$baud = 19200
Declare Sub Test1(byval Lng As Long)
Declare Sub Test2(byref Lng As Long)
Dim Lng As Long
Dim Lng2 As Long
Lng = 12345678
Lng2 = 87654321
Call Test1(lng)
Call Test1(lng2)
Call Test2(lng)
Call Test2(lng2)
Return

Sub Test1(byval Lng As Long)
Dim Lngbytes(4) As Byte At Lng Overlay 'geht auf die globale lng!!!!!
Print Lngbytes(1)
Print Lngbytes(2)
Print Lngbytes(3)
Print Lngbytes(4)
End Sub

Sub Test2(byref Lng2 As Long)
Dim Lng2bytes(4) As Byte At Lng2 Overlay 'geht auf die globale lng2!!!!!
Print Lng2bytes(1)
Print Lng2bytes(2)
Print Lng2bytes(3)
Print Lng2bytes(4)
End Sub

Die Overlays beziehen sich jetzt (klarerweise?!) auf die Speicherplätze 
der globalen Variablen LNG und LNG2 des Hauptprogrammes. Ganz zufrieden 
bin ich mit solchen Ergebnissen vor allem punkto strukturierter 
Programmierung nicht ... werd wohl auf die Byteslösung ausweichen oder 
eine globale Hilfsvariable mit Byte-Overlay verwenden.

So funktionierts meines Erachtens am Klarsten (mit globaler 
Hilfsvariable x):

$baud = 19200
Declare Sub Test(byref Lng As Long)
Dim Lng As Long
Dim Lng2 As Long
Dim X As Long
Dim Xbytes(4) As Byte At X Overlay
Lng = 12345678
Lng2 = 87654321
Call Test(lng)
Call Test(lng2)
Return

Sub Test(byref Lng As Long)
X = Lng
Print Xbytes(1)
Print Xbytes(2)
Print Xbytes(3)
Print Xbytes(4)
End Sub

Bascom ist halt so schön zu programmieren, weil es so total ähnlich zu 
VBA und .NET ist, allerdings bei der durchstrukturierten Programmierung 
muss man sich umstellen und Abstriche in Kauf nehmen.. sonst wärs ja C