Newsgroup: it.comp.lang.visual-basic
Titolo: [!]Servono funzioni binarie?

Salve a tutti, oggi è il mio compleanno, faccio 17 anni e vorrei farvi un
fioretto: visto che sto facendo un prog di MIDI e sto versando codice e idee
a fiumi, che ne direste se ve ne do una? E' un modulo che ho chiamato
modBinaryConversions, l'ho fatto per leggere e scrivere dai/ai file Midi. Ha
ancora l'ultimo piccolo, misero bug; siccome mi sembra difficile che
qualcuno si faccia avanti e mi dica "Dammi quel file e te lo riparo gratis",
ve lo scrivo qui sotto così chiunque può valutare il problema e,
eventualmente, risolverlo, ok?
--------------------------- cut here -------------------------------
Option Explicit
Const LowerByte As Byte = 0
Const HigherByte As Byte = 255
Const LowerInteger As Integer = -32768
Const HigherInteger As Integer = 32767
Const LowerLong As Long = -
2147483648
#
Const HigherLong As Long = 
2147483647
Const LowerSinglePositive As Single = 1.401298E-45
Const HigherSinglePositive As Single = 3.402823E+38
Const LowerSingleNegative As Single = -3.402823E+38
Const HigherSingleNegative As Single = -1.401298E-45
Const LowerDoublePositive As Double = 4.94065645841247E-324
Const HigherDoublePositive As Double = 1.79769313486231E+308
Const LowerDoubleNegative As Double = -4.94065645841247E-324
Const HigherDoubleNegative As Double = -1.79769313486231E+308
Const LowerCurrencyPositive As Currency = 0.0001@
Const HigherCurrencyPositive As Currency = 922337203685477.5807@
Const LowerCurrencyNegative As Currency = -922337203685477.5807@
Const HigherCurrencyNegative As Currency = -0.0001@
Const Bit8 = 256
Const Bit16 = 65536
Const Bit24 = 16777216
Const Bit32 = 4294967296#
Public Function IntStream(MSB As Byte, LSB As Byte) As Integer
    IntStream = MSB * Bit8 + LSB
End Function
Public Function LongStream(Byte3 As Byte, Byte2 As Byte, Byte1 As Byte,
Byte0 As Byte) As Double
    LongStream = Byte3 * Bit24 + Byte2 * Bit16 + Byte1 * Bit8 + Byte0
End Function
Public Function AddIntSign(Value As Long) As Integer
    If Value > HigherInteger Then
        AddIntSign = -(Bit16 - Value)
    Else
        AddIntSign = Value
    End If
End Function
Public Function AddLongSign(Value As Double) As Long
    If Value > HigherLong Then
        AddLongSign = -(Bit32 - Value)
    Else
        AddLongSign = Value
    End If
End Function
Public Function IntSplit(Value As Integer, ByteN As Integer) As Byte
    Select Case ByteN
        Case 1
            IntSplit = Value \ Bit8
        Case 0
            IntSplit = Value Mod Bit8
    End Select
End Function
Public Function LongSplit(Value As Long, ByteN As Integer) As Byte
    Select Case ByteN
        Case 3
            LongSplit = Val("&H" & Mid(String(8 - Len(Hex(Value)), "0") &
Hex(Value), 1, 2))
        Case 2
            LongSplit = Val("&H" & Mid(String(8 - Len(Hex(Value)), "0") &
Hex(Value), 3, 2))
        Case 1
            LongSplit = Val("&H" & Mid(String(8 - Len(Hex(Value)), "0") &
Hex(Value), 5, 2))
        Case 0
            LongSplit = Val("&H" & Mid(String(8 - Len(Hex(Value)), "0") &
Hex(Value), 7, 2))
    End Select
End Function
Public Function IntSwapByte(Value As Integer) As Long
    IntSwapByte = IntSplit(Value, 0) * Bit8 + IntSplit(Value, 1)
End Function
Public Function LongSwapByte(Value As Long) As Double
    LongSwapByte = _
        LongSplit(Value, 0) * Bit24 + _
        LongSplit(Value, 1) * Bit16 + _
        LongSplit(Value, 2) * Bit8 + _
        LongSplit(Value, 3)
End Function
Public Function LongSwapInt(Value As Long) As Integer      'In questa
funzione c'è il bug.
    LongSwapInt = _
        LongSplit(Value, 2) * Bit24 + _
        LongSplit(Value, 3) * Bit16 + _
        LongSplit(Value, 0) * Bit8 + _
        LongSplit(Value, 1)
'E qui mi da Overflow.
End Function
--------------------------- cut here -------------------------------
Adesso vi dico cosa c'è dentro: le costanti indicano solo i limiti dei
corrispondenti tipi di dati, positivi e negativi; le ultime quattro invece
servono per le funzioni, ma possono essere utilizzate tranquillamente.
IntStream e LongStream mettono 2 o 4 bytes in un Integer o in un Long.
AddIntSign permette di comprimere un intero positivo da 32768 a 65535 in un
Integer complementando a due il numero; la stessa cosa con AddLongSign, ma
tra 
2147483648
 a 4294967295. IntSplit e LongSplit fanno il contrario di
IntStream e LongStream: specificando il valore e il numero di byte (bit 0-7
e 8-15 per gli Integer, 0-7, 8-15, 16-23 e 24-31 per i Long) si ottiene il
byte corrispondente. Per LongStream ho usato temporaneamente le funzioni
stringa; sono molto lente ma le sostituirò tra breve. IntSwapByte scambia il
primo e il secondo byte di un Integer (&H1020 -> &H2010); LongSwapByte
inverte l'ordine dei quattro bytes (&H10203040 -> &H40302010), mentre
LongSwapInt DOVREBBE scambiare il primo e il secondo col terzo e il quarto
(&H10203040 -> &H30401020), ma a causa di un bug mi restituisce un Overflow.
Se riuscite a risolvermi il problema, datemi il nuovo codice che lo metto
sul sito comune, dopo avergli messo i commenti.
--
E.G. er Cicca


Ciao.
Non ho controllato ma, a occhio, se il massimo intero č 32767 tu restituisci
come valore della function un valore che senz'altro č maggiore.

come valore della function un valore che senz'altro è maggiore.
Come prima, sono senza parole.
SIETE MITICI!
E.G. er Cicca
car...@oasi.net