Mensajes

[LongToByte]

& = as long, es lo mismo...

http://wiki.elhacker.net/programacion/vb/4---principios-basicos

Spyke1 - (Alias Mr. Frogs) me copio eso; pero ya entendí que mejor declaro bien y uso la técnica de declaración Hugara (o alguna nomenclatura simple pero concreta) en lugar de los signos al final de una variable, con excepciones por ejemplo en las funciones LongToByte y ColorLongToRGB la Mascara que se efectúa con &HFF00& para obtener los Bits deseados, tendría que ser una mascara tipo Long por ello se le pone el signo & ya que si no se le pone pasa a tratarse como un valor integer, solo para casos como estos se usa dicho signo.

Código (vb) [Seleccionar] Expandir



msgbox typename(&HFF00&)
msgbox typename(&HFF00)



Dulces Lunas!¡.

Cambio rapido del signo a un valor dado N ( habitualmente:  lval=(lval*(-1)) )

Código (Vb) [Seleccionar] Expandir



Private Sub lChangeSign(ByRef lVal As Long)
   '   //  Para cualquier valor que lVal pueda tomar.
   '   //  Cambia de signo a un numero( + a - y de - a +).
   lVal = ((Not lVal) + 1)
End Sub
'   //  Para valores tipo Integer
Private Sub iChangeSign(ByRef iVal As Integer)
   '   //  Para cualquier valor que iVal pueda tomar.
   '   //  Cambia de signo a un numero( + a - y de - a +).
   lVal = ((Not lVal) + 1)
End Sub



Dulce sLunas!¡.

[Por si se aparece Karkrack, Cobein o similares NO ASM-Inline]

.
Crear una función que mueva los bit's (Por si se aparece Karkrack, Cobein o similares NO ASM-Inline) a la izquierda o derecha.

(Los Números binarios se leen de izquierda a derecha, quien no tenga idea use la calculadora de windows o investigue en google como determinar el valor en Base 10).

Los ejemplos son considerando {1 Byte = 8 Bits, con el byte de signo.} la función deberá trabajar con (4 Bytes = 32 bit's = Long)

Ejemplo 1:

Se ingresa el numero  45  de desplazan 2 bit's a la izquierda el resultado es 180
es decir en binario:
00101101  {Desplazando 2 bit's Resultado--->} 10110100

Ejemplo 2:

Se ingresa el numero (-128) se desplazan 5 bit's a la izquierda el resultado es: 0
es decir en binario:
10000000 {Desplazando 5 bit's Resultado--->} 00000000

Ejemplo 3:

Se ingresa el numero 1 se desplazan 5 bit's a la izquierda el resultado es: 32
es decir en binario:
00000001 {Desplazando 5 bit's Resultado--->} 00100000

Ejemplo 4:

Se ingresa el numero 1 se desplazan 5 bit's a la derecha el resultado es: 0
es decir en binario:
00000001 {Desplazando 5 bit's Resultado--->} 00000000

Ejemplo 5:

Se ingresa el numero (-2) se desplazan 5 bit's a la derecha el resultado es: -1
es decir en binario:
11111110 {Desplazando 5 bit's Resultado--->} 11111111

Ejemplo 6:

Se ingresa el numero (-1) se desplazan 5 bit's a la derecha el resultado es: -1
es decir en binario:
11111111 {Desplazando 5 bit's Resultado--->} 11111111

Formato de la funcion:

Código (Vb) [Seleccionar] Expandir



Public Function Bits_d(ByVal lVal As Long, Optional lDesplazamiento As Integer) As Long
'   //  lVal                Indica el valor ingresado (Base 10).
'   //  lDesplazamiento     Indica la longitud de bit's a dezplazar.
'   //  Bits_d              Retorna el resultado Final (Base 10)
   ...
End Function




Edito:


Codigo para probar los resultados:

Código (Vb) [Seleccionar] Expandir



Private Sub Form_Load()
Dim lres        As Long
    lres = DebugAndRet(Bits_d(267614144, (-1)))
    lres = DebugAndRet(Bits_d(lres, (-6)))
    lres = DebugAndRet(Bits_d(lres, 2))
    lres = DebugAndRet(Bits_d(lres, 2))
    lres = DebugAndRet(Bits_d(lres, 2))
    lres = DebugAndRet(Bits_d(lres, 2))
    lres = DebugAndRet(Bits_d(lres, (-2)))
    lres = DebugAndRet(Bits_d(lres, (-24)))
End Sub

Private Function DebugAndRet(ByVal lVal As Long) As Long
    Debug.Print lVal
    DebugAndRet = lVal
End Function



Resultados en el Debug:

Código [Seleccionar] Expandir



535228288
-105127936
-26281984
-6570496
-1642624
-410656
-1642624
-2147483648



Resultados en Binario:
Pruebas con Test Manual...

Código [Seleccionar] Expandir



00001111111100110111011111000000  <-- {267614144}  <--- De este binario se parte...
00011111111001101110111110000000  <-- {-01}
11111001101110111110000000000000  <-- {-06}
11111110011011101111100000000000  <-- {+02}
11111111100110111011111000000000  <-- {+02}
11111111111001101110111110000000  <-- {+02}
11111111111110011011101111100000  <-- {+02}
11111111111001101110111110000000  <-- {-02}
10000000000000000000000000000000  <-- {-24} <-- {-2147483648}



Dulces Lunas!¡.

.

Código (vb) [Seleccionar] Expandir



Private Sub Form_Load()
Dim ff As Integer
ff = FreeFile
Open "c:\aaa.txt" For Binary As ff
    Put ff, (LOF(ff) + 1), "Datos"
Close ff
End Sub



Dulces Lunas!¡.

.
Solo agrego lo siguiente.

Código (Vb) [Seleccionar] Expandir



    '   Cada Instruccion pesa {1 Bytes} y el numero de "_" son la cantidad de bytes esperados habitualmente si son 4 es que sea normalmente un puntero, pero eso depende del formato de la instruccion.
    '   Para informacion de los OpCodes:
    '   //  http://ref.x86asm.net/geek.html
    '   PUSH ____
    '   PUSH ____
    '   PUSH ____
    '   PUSH ____
    '   MOV EAX, ____
    '   CALL EAX
    '   RET



Dulces Lunas!¡.

.
el código lo pongo publico ya que a mas de a uno le interese a la larga, no soy experto en ASM pero bueno.

Código (vb) [Seleccionar] Expandir



Option Explicit

Private Declare Function LoadLibrary Lib "kernel32.dll" Alias "LoadLibraryA" (ByVal lpLibFileName As String) As Long
Private Declare Function GetProcAddress Lib "kernel32.dll" (ByVal hModule As Long, ByVal lpProcName As String) As Long
Private Declare Function CallWindowProc Lib "USER32" Alias "CallWindowProcW" (ByVal lpPrevWndFunc As Long, ByVal hwnd As Long, ByVal msg As Long, ByVal wParam As Long, ByVal lParam As Long) As Long

Private Sub form_load()
Dim bASM(0 To 27)           As Byte
Dim i                       As Integer
Dim sMsg                    As String
Dim sTitulo                 As String

    sMsg = "Hola Mundo"
    sTitulo = "Titulo de un msgbox"

    '   Cada Instruccion pesa {1 Bytes} y el numero de "_" son la cantidad de bytes esperados habitualmente si son 4 es que sea normalmente un puntero, pero eso depende del formato de la instruccion.
    '   Para informacion de los OpCodes:
    '   //  http://ref.x86asm.net/geek.html
    '   PUSH ____
    '   PUSH ____
    '   PUSH ____
    '   PUSH ____
    '   MOV EAX, ____
    '   CALL EAX
    '   RET
    i = 0
    bASM(i) = &H68: i = LongToByte(vbYesNoCancel, bASM(), i + 1)    ' PUSH {vbYesNoCancel}      5 bytes ( 1(&H68) + long(vbYesNoCancel) ).
    bASM(i) = &H68: i = LongToByte(StrPtr(sTitulo), bASM(), i + 1)  ' PUSH {StrPtr(sTitulo)}    5 bytes ( 1(&H68) + long(StrPtr(sTitulo)) )..
    bASM(i) = &H68: i = LongToByte(StrPtr(sMsg), bASM(), i + 1)     ' PUSH {StrPtr(sMsg)}       5 bytes ( 1(&H68) + long(StrPtr(sMsg)) )..
    bASM(i) = &H68: i = LongToByte(&H0, bASM(), i + 1)              ' PUSH {&H0}                5 bytes ( 1(&H68) + long(&H0) )..
   
    ' MOV {EAX},{LongToByte(GetProcAddress(LoadLibrary("user32.dll"), "MessageBoxW")}
    bASM(i) = &HB8: i = LongToByte(GetProcAddress(LoadLibrary("user32.dll"), "MessageBoxW"), bASM(), i + 1) ' 5 bytes
    bASM(i) = &HFF: i = i + 1 ' CALL ___    1 bytes
    bASM(i) = &HD0: i = i + 1 ' EAX         1 bytes
    bASM(i) = &HC3: i = i + 1 ' RET         1 bytes
    MsgBox CallWindowProc(ByVal VarPtr(bASM(0)), 0&, 0&, 0&, 0&)    ' Run ASM
End Sub

Private Function LongToByte(ByVal lLong As Long, ByRef bReturn() As Byte, Optional i As Integer = 0) As Long
    bReturn(i) = lLong And &HFF
    bReturn(i + 1) = (lLong And &HFF00&) \ &H100
    bReturn(i + 2) = (lLong And &HFF0000) \ &H10000
    bReturn(i + 3) = (lLong And &HFF000000) \ &H1000000
    LongToByte = i + 4
End Function



Dulces Lunas!¡.

Solo aclaro que los numeros binarios de leen de derecha a izquierda mas no de izquierda a derecha

P.E.

Código [Seleccionar] Expandir



Esto esta MAL.
    58 = 01011100   <--- Este binario no es 58 realmente es el numero 92
   232 = 00010111  <--- Este binario no es 232 realmente es el numero 23
        ----------
         00010100   =40  <--- Este binario no es 40 realmente es el numero 20



Realmente es asi:

Código [Seleccionar] Expandir



CORRECTO:
    58 = 00111010
   232 = 11101000
        ----------
         00101000   =40



Esto es debida a que los 0 a la izquierda del ultimo 1 no tienen valor alguno pero si los 0 a la derecha

... (2a la N) ... 128 64 32 16 8 4 2 1 0
<-----------------------------------|
Dulces Lunas!¡.

Código (Vb) [Seleccionar] Expandir



Public Function LongToByte(ByVal lVal As Long) As Byte()
Dim bRet(0 To 3)        As Byte
   bRet(3) = (lVal And &HFF000000) \ &H1000000
   bRet(2) = (lVal And &HFF0000) \ &H10000
   bRet(1) = (lVal And &HFF00&) \ &H100
   bRet(0) = (lVal And &HFF)
   LongToByte = bRet
End Function



Código (Vb) [Seleccionar] Expandir



Private sub ColorLongToRGB(ByVal LngColor As Long, ByRef OutRed As Byte, ByRef OutGreen As Byte, ByRef OutBlue As Byte)
  OutBlue = (LngColor And &HFF0000) \ &H10000
  OutGreen = (LngColor And &HFF00&) \ &H100
  OutRed = (LngColor And &HFF)
End sub



Dulces Lunas!¡.

.
yo lo haria asi:

Nesesitas un Boton y pegar lo siguiente en un form.

Nunca me a gustado declarar las apis como as Any asi que lo modifico para que trabaje con punteros en lugar de referencias.

Código (Vb) [Seleccionar] Expandir



Option Explicit

Private Const PROCESS_ALL_ACCESS As Long = &H1F0FFF
Private Declare Function GetWindowThreadProcessId Lib "user32" (ByVal hWnd As Long, lpdwProcessId As Long) As Long
Private Declare Function OpenProcess Lib "kernel32" (ByVal dwDesiredAccess As Long, ByVal bInheritHandle As Long, ByVal dwProcessId As Long) As Long
Private Declare Function ReadProcessMemory Lib "kernel32" (ByVal hProcess As Long, ByVal lpBaseAddress As Long, lpBuffer As Long, ByVal nSize As Long, lpNumberOfBytesRead As Long) As Long
Private Declare Function CloseHandle Lib "kernel32" (ByVal hObject As Long) As Long

Private Memoria(0 To 100)   As Long

Private Sub Command1_Click()
Dim i As Long
Dim bToFind()               As Byte
   For i = 20 To 35
       Memoria(i) = (i + 4658984)
   Next
   bToFind() = LongToByte(4658984 + 20)
   ' // tiene que dar la dirrecion en memoria del indice de    varptr(Memoria(20))
   MsgBox VarPtr(Memoria(20)) = FindInMemory(Me.hWnd, bToFind, VarPtr(Memoria(0)), (VarPtr(Memoria(100))) + LenB(Memoria(100)))
End Sub

Public Function FindInMemory(ByVal hWnd As Long, _
                            ByRef bToFind() As Byte, _
                            ByVal lptrIni As Long, _
                            ByVal lptrend As Long) As Long
' No termine bien la funcion solo es un pequeño Esbozo para el tema.
Dim hproc                   As Long
Dim babuff()                As Byte
Dim llnbuff                 As Long
Dim llnread                 As Long
Dim lret                    As Long
Dim lptradd                 As Long
Dim pId                     As Long

Dim q                       As Long
Dim c                       As Long

   FindInMemory = 0
   llnbuff = ArrayCount(bToFind())
   If Not ((lptrIni = 0) And (hWnd = 0) And (llnbuff = 0) And (lptrend = 0)) And (llnbuff <= (lptrend - lptrIni)) Then
       GetWindowThreadProcessId hWnd, pId
       hproc = OpenProcess(PROCESS_ALL_ACCESS, False, pId)
       If Not (hproc = 0) Then
           ReDim babuff(0 To (llnbuff - 1))
           lptradd = 0
           Do  '   //  Se puede optimizar bastante...
               ReadProcessMemory hproc, ByVal (lptrIni + lptradd), ByVal VarPtr(babuff(0)), llnbuff, llnread
               lret = InByteArray(0, bToFind, babuff)
               If (lret >= 0) Then
                   FindInMemory = ((lptrIni + lptradd) + lret)
                   Exit Do
               End If
               lptradd = (lptradd + 1)
               DoEvents
           Loop Until ((lptrIni + lptradd) = (lptrend - llnbuff))
           CloseHandle hproc
       End If
   End If
End Function



en un modulo:

Código (Vb) [Seleccionar] Expandir



Option Explicit

Public Declare Function VarPtrA Lib "msvbvm60.dll" Alias "VarPtr" (ByRef Ptr() As Any) As Long
Public Declare Sub lCopyMemory Lib "kernel32.dll" Alias "RtlMoveMemory" (ByVal Destination As Long, ByVal Source As Long, ByVal Length As Long)

Public Const InvalidValueArray = -1

Public Function InByteArray(ByVal lStart As Long, ByRef bArray1() As Byte, ByRef bArray2() As Byte) As Long
Dim llna1               As Long
Dim llna2               As Long
Dim llimt               As Long
Dim q                   As Long
Dim c                   As Long
   InByteArray = (-1)
   If (lStart >= 0) Then
       llna1 = ArrayCount(bArray1())
       llna2 = ArrayCount(bArray2())
       If Not ((llna1 = 0) And (llna2 = 0)) Then
           llimt = (llna1 - llna2)
           If (llimt >= 0) Then
               q = lStart
               Do While (q <= llimt)
                   Do While (bArray1(q + c) = bArray2(c))
                       c = (c + 1)
                       If (c = llna2) Then
                           InByteArray = q
                           GoTo ExitFunc
                       End If
                   Loop
                   q = ((q + c) + 1)
                   c = 0
               Loop
           End If
       End If
   End If
ExitFunc:
End Function

Public Function LongToByte(ByVal lVal As Long) As Byte()
Dim bRet(0 To 3)        As Byte
   bRet(3) = (lVal And &HFF000000) \ &H1000000
   bRet(2) = (lVal And &HFF0000) \ &H10000
   bRet(1) = (lVal And &HFF00&) \ &H100
   bRet(0) = (lVal And &HFF)
   LongToByte = bRet
End Function

Public Function ArrayCount(ByRef vArray() As Byte)
   If Itsarrayini(VarPtrA(vArray)) Then
       If LBound(vArray) = 0 Then
           ArrayCount = 1
       End If
       ArrayCount = ArrayCount + UBound(vArray)
   Else
       ArrayCount = 0
   End If
End Function

Public Function Itsarrayini(ByVal lngPtr As Long, Optional LnBytes As Long = 4) As Boolean
Dim lng_PtrSA                   As Long
   If lngPtr <> 0 And LnBytes > 0 Then
       Call lCopyMemory(ByVal VarPtr(lng_PtrSA), ByVal lngPtr, LnBytes)
       Itsarrayini = Not lng_PtrSA = 0
   End If
End Function



Temibles Lunas!¡.

Agregue un proceso en el 1er post para poder Regenerar un numero X.

Dulces Lunas!¡.