Assemblercodes für das neue X4

    Diese Seite verwendet Cookies. Durch die Nutzung unserer Seite erklären Sie sich damit einverstanden, dass wir Cookies setzen. Weitere Informationen

    Unsere Datenschutzerklärung wurde aktualisiert. Mit der Nutzung unseres Forums akzeptierst Du unsere Datenschutzerklärung. Du bestätigst zudem, dass Du mindestens 16 Jahre alt bist.

    • p. specht schrieb:

      Bitte wie komme ich an die Call-Adresse des mit ASM erzeugten Maschinencodes?
      ProcAddr liefert derzeit Fehlermeldung ...
      Zur Zeit überhaupt nicht. ProcAddr funktioniert nur für XProfan-Prozeduren und weist diesen eine feste Adresse zu. Mit ASM-ENDASM werden die Funktionen genau so in die interne Liste externer Funktionen eingetragen, wie mit ImportFunc oder ImportDLL. Da die Funktionen ja über ihren Namen aufgerufen werden (auch in ASM-Funktionen mit FCALL), benötigt man (normalerweise) ihre Adressen nicht.

      Ich habe aber geplant, bei ASM-ENDASM zwei Systemvariablen zu füllen, die Startadresse und Länge des erzeugten Codes bereitstellen, auch wenn ich nicht so recht weiß, was man damit Sinnvolles anfangen kann.

      Gruß
      Roland
      Intel Duo E8400 3,0 GHz / 4 GB RAM / 1000 GB HDD / ATI Radeon HD4770 512 MB / Windows 7(32) - XProfan X4
      AMD Athlon II X2 2,9 GHz / 3 GB RAM / 500 GB HDD / ATI Radeon 3000 (onboard) / Windows 10(64) - XProfan X4

      http://www.xprofan.de

    • ad 39: Ich habe beobachtet, daß "Vorwärtsverkettete Indexlisten" im Grundzustand (also vor dem mitsortiert werden nach der neuen Ordnung) immer auf das NÄCHSTE Element der aktuellen Ordnung weisen sollten, nicht auf sich selbst. Auch dazu wäre es super, den Basiswert der Zählung bei 1 anzusetzen, da ja das nächste anzuspringende Element der Indexordnung dann das mit dem Index 1 ist...(Ich weiß aber nicht, ob Heinz das überhaupt im Auge hatte. Es wäre jedenfalls ein weiteres Argument für Element[0]="1" ).

      ad 37: Die Call-Addy könnte sinnvoll sein, wenn mehrere ASM-ENDASM-Module zusammenarbeiten sollen. Auch Callback-Techniken benötigen das ja ... (wobei ich keine Ahnung von Callback habe). An selbstmodifizierenden Code denke ich natürlich nicht, - das wäre ja gegen alles, was den Informatik-Göttern heilig ist ...
      Gruss

      P.S: Mir gefällt sehr, daß man tatsächlich "in Line" codieren kann. Das klappt sonst in keinem der bekannten Assembler:

      Quellcode

      1. WindowTitle "Halber Sinn des Lebens":CLS:ASM "zwei",0:jmp hopp:zw:
      2. dd 42:hopp:
      3. LEA eax,[zw]:ENDASM:ASM "halb",1:mov eax,par1:mov eax,[eax]:shr eax:ENDASM
      4. Print halb(zwei()):waitinput

      Dieser Beitrag wurde bereits 3 mal editiert, zuletzt von p. specht ()

    • Besser langsam, aber dafür sorgfältig angehen...

      Die untenstehend von RGH bekanntgegebenben Neuerungen wurden in das "vorläufige Merkblatt_XASM.pdf" eingearbeitet. Die alte Download-Addy dazu ist nicht mehr gültig.

      Dafür gibt es ergänzend ein Merkblatt zu Bedingungen und Schleifen in Assembler.

      Und hier ein Testcode, der sich selbst byteweise ausgibt und dann auch im Clipboard zu finden ist.
      Gruss

      Quellcode

      1. WindowTitle "Selbsterforschung"
      2. WindowStyle 24:Window 0,0-%maxx,%maxy:showmax
      3. set("AsmMode",2):font 2
      5. ASM "Test2",1:data:
      6. mov ebx,par1:mov ecx,data:add ecx,ebx:xor eax,eax:mov al,[ecx]:exyt:
      7. ENDASM
      9. whileloop -3,-1
      10. print right$("0"+hex$(test2(&Loop)),2); '55 89 E5 = Pgm-Start
      11. endwhile
      12. print
      13. whileloop 14,19
      14. print right$("0"+hex$(test2(&Loop)),2); '89 EC 5D C2 (= Pgm-Ende)+ 04 00 (= 0004/4 = 1 Parameter)
      15. endwhile
      16. print
      17. clearclip
      18. whileloop -3,19
      19. print right$("0"+hex$(test2(&Loop)),2); 'Programm
      20. putclip right$("0"+hex$(test2(&Loop)),2)
      21. endwhile
      22. print:print "\n ASM-PGM Hex-Bytecode im Clipboard"
      23. Waitinput 15000
      Alles anzeigen
      P.S.: Vielleicht wäre eine separate Rubrik für solche und andere User-Codestücke sinnvoll.
      Dann könnte dieser Thread allein für Neuerungen reserviert bleiben...

      Dieser Beitrag wurde bereits 4 mal editiert, zuletzt von p. specht ()

    • Habe hier auch was, das 2 Strings zusammensetzen soll.
      Das hatte ich aus dem Netz auch so übernommen.
      Irgendwie mache ich da was falsch, was das Schreiben
      an bestimmte Adressen angeht.
      Hier kommt eine Fehlermeldung :

      Quellcode

      1. Declare String s1, s2
      2. s1 = "Hallo \z"
      3. s2 = "Welt\z"
      4. Cls
      6. ASM "api_strcat", 2
      7. MOV ESI, Par1
      8. MOV EDI, Par2
      9. CALL strcat
      10. strcat:
      11. XOR ECX,ECX
      12. MOV EBP,ESI
      13. lp1:
      14. LODSB
      15. OR AL,AL
      16. JZ lp1d
      17. INC ECX
      18. JMP lp1
      19. lp1d:
      20. MOV ESI,EDI
      21. MOV EBX,ECX
      22. lp2:
      23. LODSB
      24. OR AL,AL
      25. JZ lp2d
      26. MOV [EBP+EBX],AL
      27. INC EBX
      28. JMP lp2
      29. XOR AL,AL
      30. MOV [EBP+EBX],AL
      31. lp2d:
      32. ENDASM
      34. Print api_strcat(s1, s2)
      36. WaitKey
      37. End
      Alles anzeigen
      Da habe ich den Bogen noch nicht so raus.
      PS : Zuerst mußte ich alle TABs entfernen. Die mag der Inline Assembler irgendwie nicht,
      bzw. gibt mir schon in der ersten Zeile einen Fehler, wo er den Befehl nicht kennt.

    • Erst mal kann das Ergebnis so nicht funktionieren. Die Assemblerroutine gibt einen Wert in EAX zurück, das ist ein 32-Bit-Wert, also eine Zahl, kein String. Prinzipiell könnte man zwar mit ausreichenden Kenntnissen Speicher reservieren und in EAX das Handle zurückgeben... das stellt Bedingungen an den nachfolgenden Programmteil. Also lieber nicht.
      Sieh Assemblerroutinen so an, wie API-Aufrufe. Es kommt immer eine Zahl zurück. Strings kommen in einem Speicherbereich, den Du ausreichend dimensioniert als Parameter übergibst. Zudem kommt mir das Ganze irgendwie aus dem Zusammenhang gerissen vor, da taucht ein CALL in die eigene Routine auf, und es gibt kein passendes RET. CALL und RET gehören zusammen wie PUSH und POP, da immer Werte auf den Stack gelegt und wieder abgeholt werden.
      Und spiele nicht mit dem Base-Pointer, den stellt Roland schon so ein, wie er gebraucht wird.

      Gruß Volkmar

    • So, habe nun auch eine Version fertig. StrCat könnte man etwa so machen

      Quellcode

      1. Declare String s1, s2
      2. s1 = "Hall0 \z"
      3. s2 = "Welt\z"
      4. s1 = s1 + Space$(Len(s2)) ' String verlängern, um Ziel aufzunehmen
      5. Cls
      7. ASM "api_strcat", 2
      8. MOV ESI, Par1
      9. MOV EDI, Par2
      10. CLD // directionflag setzen, man weiß ja nie, wie es gerade steht :-)
      11. lp1:
      12. LODSB
      13. OR AL,AL
      14. JNZ lp1
      15. lp1d:
      16. DEC ESI
      17. XCHG ESI, EDI
      18. // Quelle und Ziel tauschen, da wir jetzt in Par1 schreiben wollen
      19. lp2:
      20. LODSB
      21. STOSB
      22. OR AL,AL
      23. JZ lp2d
      24. JMP lp2
      25. XOR AL,AL
      26. MOVSB
      27. lp2d:
      28. ENDASM
      30. Print api_strcat(s1, s2)
      31. Print Trim$(s1)+ "!!"
      32. WaitKey
      33. End
      Alles anzeigen

      Und in fremde Codes gucken ist doch gar nicht so verkehrt. Nur aus dem Zusammenhang gerissen ist da Einiges anzupassen. Im Original hat das sicher funktioniert. Aber dort mußte auch niemand auf den "Funktionsrahmen" und die Bedingungen in Profan Rücksicht nehmen. Ist also immer mit etwas Anpassung zu verwenden. Mit etwas Übung wird das schon. Ich muß jetzt auch viel nachdenken, es ist etliche Jahre her, als ich den letzten Assemblercode zusammengklopft habe ;-)
      Die Zahl, die bei Print ausgegeben wird, sagt garnichts aus, das ist der aktuelle EAX-Inhalt. Und das Trim$() bei der Ergebnisanzeige kann hier auch entfallen, da die Stringlänge vorher berechnet wurde.

      Gruß Volkmar

      PS: Code nochmal geändert, da wurde ein zusätzliches Leerzeichen eingebaut, weil das Schlußzeichen (Byte 0) als gültige Zeichenposition mitgezählt wurde, nach der dann der zweite String eingefügt wird :oops:

      Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von Volkmar ()

    • Und Speicher belegen und freigeben könnte man in etwa so machen.

      Allerdings bekomme ich es nicht mal zum kompilieren.

      Trotzdem... TEST, TEST, TEST

      Quellcode

      1. '$I Mem_ASM.INC
      2. '$H C:\XProfan\Include\Windows.ph
      4. '$IFNDEF MEM_ASM
      5. '$DEFINE MEM_ASM
      7. Declare Handle mwmem_hDLL
      9. mwmem_hDLL = UseDLL("KERNEL32.DLL")
      10. ImportFunc( mwmem_hDLL, "GetLastError", "sys_GetLastError" ) // GetLastError( )
      11. ImportFunc( mwmem_hDLL, "GlobalAlloc", "sys_GlobalAlloc" ) // GlobalAlloc( flags, Size )
      12. ImportFunc( mwmem_hDLL, "GlobalFree", "sys_GlobalFree" ) // GlobalFree( hMem )
      13. ImportFunc( mwmem_hDLL, "GlobalHandle", "sys_GlobalHandle" ) // GlobalHandle( pMem )
      14. ImportFunc( mwmem_hDLL, "GlobalLock", "sys_GlobalLock" ) // GlobalLock( hMem )
      15. ImportFunc( mwmem_hDLL, "GlobalReAlloc", "sys_GlobalReAlloc" ) // GlobalReAlloc( hMem, Size, flags )
      16. ImportFunc( mwmem_hDLL, "GlobalSize", "sys_GlobalSize" ) // GlobalSize( hMem )
      17. ImportFunc( mwmem_hDLL, "GlobalUnlock", "sys_GlobalUnlock" ) // GlobalUnlock( hMem )
      18. ImportFunc( mwmem_hDLL, "RtlFillMemory", "sys_FillMemory" ) // FillMemory( pDest, Len, Char )
      19. ImportFunc( mwmem_hDLL, "RtlMoveMemory", "sys_MoveMemory" ) // MoveMemory( pDest, pSrc, Len ) 'Überlappung erlaubt
      20. ImportFunc( mwmem_hDLL, "RtlZeroMemory", "sys_ZeroMemory" ) // ZeroMemory( pDest, Len )
      22. // EAX, ECX, EDX müssen selbst gerettet werden (da der Windows-Standard diese zu Freiwild erklärt)
      23. /*
      24. Inhalt:
      25. Mem_New - pMem = Mem_New( Size ) - Speicher belegen/reservieren
      26. Mem_Free - bool = Mem_Free( pMem ) - Speicher freigeben
      27. Mem_Size - Size = Mem_Size( pMem ) - Größe des belegten Speichers ermitteln
      28. Mem_Clear - Size = Mem_Clear( pMem ) - Speicher mit Nullen überschreiben
      29. Mem_Fill - bool = Mem_Fill( pMem, Anz, Fill ) - Der angegebene belegte Speicherbereich wird mit Füllzeichen aufgefüllt.
      30. Mem_Move - bool = Mem_Move( Ziel, Quelle, Anz ) - Speicherinhalte kopieren
      31. Mem_Resize - pMem = Mem_Resize( pMem, Size ) - Speichergröße ändern/redimensionieren
      32. */
      34. ' ********************
      35. ' Mem_New() - Speicher belegen/reservieren
      36. ' pMem& = Mem_New( Size& )
      37. ' Speicher belegen
      38. ' Reserviert "Size" Bytes Speicherplatz und liefert den Speicherzeiger als Rückgabewert.
      39. ASM "Mem_New", 1
      40. PUSH ECX
      42. MOV ECX, 66 // GMEM_MOVEABLE = 2 | GMEM_ZEROINIT = 64 | GMEM_PTR = 66
      43. MOV EAX, PAR1 // Size
      45. CMP EAX, EAX // Null ?
      46. JZ @@New_Done
      48. PUSH EAX // Size
      49. PUSH ECX // Flags
      50. FCALL "sys_GlobalAlloc"
      52. CMP EAX, EAX // Null ?
      53. JZ @@New_Done
      55. PUSH EAX // hMem
      56. FCALL "sys_GlobalLock"
      58. @@New_Done:
      59. POP ECX
      60. ENDASM
      62. ' ********************
      63. ' Mem_Free() - Speicher freigeben
      64. ' bool% = Mem_Free( pMem& )
      65. ' Speicher freigeben
      66. ' Gibt den Speicherbereich auf den der Speicherzeiger zeigt wieder frei.
      67. ASM "Mem_Free", 1
      68. PUSH ECX
      70. MOV EAX, PAR1 // pMem
      72. CMP EAX, EAX
      73. JZ @@Free_Done
      75. PUSH EAX // pMem
      76. FCALL "sys_GlobalHandle"
      78. CMP EAX, EAX
      79. JZ @@Free_Error
      81. MOV ECX, EAX
      83. PUSH ECX // hMem
      84. FCALL "sys_GlobalUnlock"
      86. CMP EAX, EAX
      87. JZ @@Free_Error
      89. PUSH ECX // hMem
      90. FCALL "sys_GlobalFree"
      92. CMP EAX, EAX
      93. JNZ @@Free_Done
      95. @@Free_Error:
      96. FCALL "sys_GetLastError"
      98. @@Free_Done:
      99. POP ECX
      100. ENDASM
      102. ' ********************
      103. ' Mem_Size() - Größe des belegten Speichers ermitteln
      104. ' Size& = Mem_Size( pMem& )
      105. ' Ermittelt die Speichergröße auf die der Speicherzeiger zeigt.
      106. ' Liefert die Größe des Bereiches zurück.
      107. ASM "Mem_Size", 1
      108. PUSH ESI
      109. PUSH EDI
      111. XOR EDI,EDI
      112. MOV ESI, PAR1 // pMem
      114. CMP ESI, ESI
      115. JZ @@Size_Done
      117. PUSH ESI // pMem
      118. FCALL "sys_GlobalHandle" // --> hMem
      120. MOV ESI, EAX // hMem
      122. CMP EAX, EAX
      123. JZ @@Size_Error
      125. PUSH ESI // hMem
      126. FCALL "sys_GlobalSize" // size
      128. MOV EDI, EAX // size
      129. JNZ @@Size_Done
      131. @@Size_Error:
      132. FCALL "sys_GetLastError"
      134. @@Size_Done:
      135. MOV EAX,EDI
      136. POP EDI
      137. POP ESI
      138. ENDASM
      140. ' ********************
      141. ' Mem_Clear() - Speicher mit Nullen überschreiben
      142. ' Size& = Mem_Clear( pMem& )
      143. ' Speicher mit Nullen beschreiben
      144. ' Der angegebene (gesamte) Speicherbereich wird mit binären Nullen überschrieben.
      145. ' Für eine Teilfüllung ist Mem_Fill() zu nutzen.
      146. ' benötigt Mem_Size(), "ZeroMemory"
      147. ' Ergebnis: Größe des überschriebenen Bereiches
      148. ASM "Mem_Clear", 1
      149. PUSH ESI
      151. XOR EAX, EAX
      152. MOV ESI, PAR1 // pMem
      154. CMP ESI, ESI
      155. JZ @@Clear_Done
      157. PUSH ESI // pMem
      158. FCALL "Mem_Size"
      160. CMP EAX, EAX // size
      161. JZ @@Clear_Done
      163. PUSH EAX // size
      164. PUSH ESI // pMem
      165. FCALL "sys_ZeroMemory"
      167. @@Clear_Done:
      168. POP ESI
      169. ENDASM
      171. ' ********************
      172. ' Mem_Fill() - Der angegebene belegte Speicherbereich wird mit Füllzeichen aufgefüllt.
      173. ' bool% = Mem_Fill( pMem&, Anzahl&, FüllChars$ )
      174. ' belegten Speicher füllen
      175. ' Ist Anzahl = 0 dann wird Anzahl auf Mem_Size(pMem) gesetzt.
      176. ' Der angegebene Speicherbereich wird mit Füllzeichen aufgefüllt.
      177. ' - ohne diese Angabe wird mit Chr$(0) aufgefüllt
      178. ' - bei einem Zeichen wird sys_FillMemory() genutzt
      179. ' - bei mehreren Zeichen wird sys_MoveMemory() genutzt
      180. ASM "Mem_Fill", 3
      181. PUSH ESI
      182. PUSH EDI
      183. PUSH ECX
      184. PUSH EBX
      185. PUSH EDX
      187. MOV ESI, PAR3 // FillChars
      188. MOV ECX, PAR2 // Anzahl
      189. MOV EDI, PAR1 // pMem
      190. MOV EBX, [ESI - 4] // Len(FillChars)
      192. PUSH EDI // pMem
      193. FCALL "Mem_Size"
      195. CMP ECX, EAX // Anzahl <= Size ?
      196. JBE @@Fill_Anz_Inside
      198. MOV ECX, EAX // neue Anzahl
      200. @@Fill_Anz_Inside:
      201. CMP ECX, ECX // Anzahl = 0 ?
      202. JZ @@Fill_Done
      204. CMP EBX, 1 // FillChars = Null or 1 ? (nein, dann Hauptstück)
      205. JA @@Fill_more
      207. // 1 Zeichen
      208. XOR EDX, EDX // Vorgabe ist Chr$(0)
      209. CMP ESI, ESI // FillChars = NullString ?
      210. JZ @@Fill_Start
      212. MOV DL, [ESI] // Nein, dann FillChar holen
      214. @@Fill_Start:
      215. // Bereich mit einem Zeichen füllen
      216. PUSH EDX // char
      217. PUSH ECX // Anzahl
      218. PUSH EDI // pMem
      219. FCALL "sys_FillMemory"
      220. JMP @@Fill_Done
      222. // --------------------
      223. @@Fill_more:
      224. CMP EBX, ECX // LEN( FillChars ) >= Anzahl ?
      225. JAE @@Fill_MoveOne
      227. // Da wir den Füllstring mehrmals schreiben wird die Länge benötigt
      228. PUSH EBX // Len(FillChars)
      230. // ----------
      231. @@Fill_Loop:
      232. CMP ECX, EBX // Anzahl < Len(FillChars)
      233. JAE @@Fill_Hop // Nein, weiter (sonst den Rest)
      235. POP EBX // Len(FillChars)
      236. MOV EBX,ECX // überschreibe mit Rest
      237. PUSH EBX // Rest
      239. @@Fill_Hop:
      240. PUSH EBX // Len(FillChars) (oder Rest)
      241. PUSH ESI // FillChars
      242. PUSH EDI // pMem
      243. FCALL "sys_MoveMemory"
      245. POP EBX // Len(FillChars)
      246. PUSH EBX // Len(FillChars)
      247. ADD EDI, EBX // pMem + Len(FillChars)
      248. SUB ECX, EBX // Anzahl - Len(FillChars)
      250. CMP ECX, ECX // Anzahl > 0
      251. JA @@Fill_Loop
      253. // --------------------
      254. // gesicherten Wert wieder entfernen
      255. POP EBX // Len(FillChars)
      256. JMP @@Fill_Done
      258. @@Fill_MoveOne:
      259. // Es sind mehr Füllzeichen als der Bereich groß ist.
      260. // Das läßt sich in einem Rutsch erledigen.
      261. PUSH ECX // Anzahl
      262. PUSH ESI // FillChars
      263. PUSH EDI // pMem
      264. FCALL "sys_MoveMemory"
      266. @@Fill_Done:
      267. POP EDX
      268. POP EBX
      269. POP ECX
      270. POP EDI
      271. POP ESI
      272. ENDASM
      274. ' ********************
      275. ' Mem_Move() - Speicherinhalte kopieren
      276. ' bool = Mem_Move( Ziel&, Quelle&, Anzahl& )
      277. ' Der angegebene Quellbereich wird in den Zielbereich kopiert.
      278. ' (Überlappungen von Quelle und Ziel sind hier erlaubt)
      279. ASM "Mem_Move", 3
      280. PUSH ESI
      281. PUSH EDI
      282. PUSH ECX
      283. //
      284. XOR EAX, EAX // 0 = es wurde nichts kopiert
      285. MOV ECX, PAR3 // Anzahl
      286. MOV ESI, PAR2 // pQuelle
      287. MOV EDI, PAR1 // pZiel
      288. //
      289. CMP ESI, ESI // Anzahl = 0 ?
      290. JZ @@Move_Done
      291. CMP ESI, ESI // Quelle = Null
      292. JZ @@Move_Done
      293. CMP EDI, EDI // Ziel = Null
      294. JZ @@Move_Done
      296. PUSH ECX // Anzahl
      297. PUSH ESI // pQuelle
      298. PUSH EDI // pZiel
      299. FCALL "sys_MoveMemory"
      301. @@Move_Ok:
      302. INC EAX // 1 = Kopieren wurde durchgeführt
      304. @@Move_Done:
      305. POP ECX
      306. POP EDI
      307. POP ESI
      308. ENDASM
      310. ' ********************
      311. ' Mem_Resize() - Speichergröße ändern/redimensionieren
      312. ' pMem& = Mem_Resize( pMem&, Size& )
      313. ' Speicher redimensionieren
      314. ' Ändert die Speichergröße auf die der Speicherzeiger zeigt.
      315. ' Die Größe des angegebenen Speicherbereiches wird auf die neue Größe geändert (wenn ungleich).
      316. ' Bei einer Vergrößerung des Bereiches bleiben alle Daten erhalten,
      317. ' bei einer Verkleinerung nur der vordere Teil. (!!!ohne Gewähr!!!)
      318. ' Liefert den neuen Speicherzeiger zurück.
      319. ASM "Mem_Resize", 2
      320. PUSH ECX
      321. PUSH ESI
      322. PUSH EDI
      324. MOV EDI, PAR2 // Size
      325. MOV ESI, PAR1 // pMem
      327. CMP ESI, ESI // Nullzeiger ? Dann Mem_New(Size)
      328. JZ @@Resize_New
      330. PUSH ESI // pMem
      331. FCALL "sys_GlobalHandle" // --> hMem
      333. CMP ESI, ESI
      334. JZ @@Resize_Error
      336. MOV ESI, EAX // hMem
      337. PUSH ESI // hMem
      338. FCALL "sys_GlobalSize" // OldSize
      340. CMP EAX, EAX // Null
      341. JZ @@Resize_Error
      343. CMP EAX, EDI // OldSize = Size ? dann keine Größenänderung
      344. JZ @@Resize_Done
      346. PUSH ESI // hMem
      347. FCALL "sys_GlobalUnlock"
      349. MOV EAX, 2 // GMEM_MOVEABLE = $2
      350. PUSH EAX // flags
      351. PUSH EDI // size
      352. PUSH ESI // hMem
      353. FCALL "sys_GlobalReAlloc"
      354. MOV ESI, EAX // hMem
      356. CMP EAX, EAX // Null
      357. JZ @@Resize_Error
      359. PUSH ESI // hMem
      360. FCALL "sys_GlobalLock"
      361. MOV ESI, EAX // pMem
      363. CMP EAX, EAX // Null
      364. JZ @@Resize_Error
      365. JMP @@Resize_Done
      367. @@Resize_New:
      368. PUSH EDI // Size
      369. FCALL "Mem_New"
      371. MOV ESI, EAX // pMem
      372. JMP @@Resize_Done
      374. @@Resize_Error:
      375. FCALL "sys_GetLastError" // ohne Parameter
      377. @@Resize_Done:
      378. MOV EAX, ESI
      379. POP EDI
      380. POP ESI
      381. POP ECX
      382. ENDASM
      385. '$ENDIF
      387. Cls
      389. Declare long test1
      391. Print "Neu"
      392. test1 = Mem_New( 200 )
      393. Print "Adresse: "; test1
      394. Print " Größe: "; Mem_Size(test1)
      395. Mem_Free(test1)
      396. WaitInput
      397. End
      Alles anzeigen
      Programmieren, das spannendste Detektivspiel der Welt.

    • ... und davon abgesehen: Ab der nächsten Alphaversion wird es "FCALL name" nicht mehr geben, dafür funktionieren dann direkt "CALL @name" und "CALL label".

      Gruß
      Roland
      Intel Duo E8400 3,0 GHz / 4 GB RAM / 1000 GB HDD / ATI Radeon HD4770 512 MB / Windows 7(32) - XProfan X4
      AMD Athlon II X2 2,9 GHz / 3 GB RAM / 500 GB HDD / ATI Radeon 3000 (onboard) / Windows 10(64) - XProfan X4

      http://www.xprofan.de

    • Dann funktioniert das Testbeispiel auch schon.
      Zuerst suchte ich nach Mem_ASM.lst, aber alle enthaltenen Routinen erscheinen separat. :thumbsup:
      Es sind aber nur New,Free,Size gründlich geprüft.

      Quellcode

      1. '$I Mem_ASM.INC
      2. '$H C:\XProfan\Include\Windows.ph
      4. Set("AsmMode",1) ' nur zum testen
      6. '$IFNDEF MEM_ASM
      7. '$DEFINE MEM_ASM
      9. Declare Long mem_v_Error
      10. Declare Handle mem_v_hDLL
      12. mem_v_hDLL = UseDLL("KERNEL32.DLL")
      13. ImportFunc( mem_v_hDLL, "GetLastError", "" ) // GetLastError( )
      14. ImportFunc( mem_v_hDLL, "GlobalAlloc", "" ) // GlobalAlloc( flags, Size )
      15. ImportFunc( mem_v_hDLL, "GlobalFree", "" ) // GlobalFree( hMem )
      16. ImportFunc( mem_v_hDLL, "GlobalHandle", "" ) // GlobalHandle( pMem )
      17. ImportFunc( mem_v_hDLL, "GlobalLock", "" ) // GlobalLock( hMem )
      18. ImportFunc( mem_v_hDLL, "GlobalReAlloc", "" ) // GlobalReAlloc( hMem, Size, flags )
      19. ImportFunc( mem_v_hDLL, "GlobalSize", "" ) // GlobalSize( hMem )
      20. ImportFunc( mem_v_hDLL, "GlobalUnlock", "" ) // GlobalUnlock( hMem )
      21. ImportFunc( mem_v_hDLL, "RtlFillMemory", "" ) // FillMemory( pDest, Len, Char )
      22. ImportFunc( mem_v_hDLL, "RtlMoveMemory", "" ) // MoveMemory( pDest, pSrc, Len ) 'Überlappung erlaubt
      23. ImportFunc( mem_v_hDLL, "RtlZeroMemory", "" ) // ZeroMemory( pDest, Len )
      25. // EAX, ECX, EDX müssen selbst gerettet werden (da der Windows-Standard diese zu Freiwild erklärt)
      26. /*
      27. Inhalt:
      28. Mem_New - pMem = Mem_New( Size ) - Speicher belegen/reservieren
      29. Mem_Free - bool = Mem_Free( pMem ) - Speicher freigeben
      30. Mem_Size - Size = Mem_Size( pMem ) - Größe des belegten Speichers ermitteln
      31. Mem_Clear - Size = Mem_Clear( pMem ) - Speicher mit Nullen überschreiben
      32. Mem_Fill - bool = Mem_Fill( pMem, Anz, Fill ) - Der angegebene belegte Speicherbereich wird mit Füllzeichen aufgefüllt.
      33. Mem_Move - bool = Mem_Move( Ziel, Quelle, Anz ) - Speicherinhalte kopieren
      34. Mem_Resize - pMem = Mem_Resize( pMem, Size ) - Speichergröße ändern/redimensionieren
      35. */
      37. ' ********************
      38. ' Mem_New() - Speicher belegen/reservieren
      39. ' pMem& = Mem_New( Size& )
      40. ' Speicher belegen
      41. ' Reserviert "Size" Bytes Speicherplatz und liefert den Speicherzeiger als Rückgabewert.
      42. ASM "Mem_New", 1
      43. PUSH ECX
      45. MOV ECX, 66 // GMEM_MOVEABLE = 2 | GMEM_ZEROINIT = 64 | GMEM_PTR = 66
      46. MOV EAX, PAR1 // Size
      48. CMP EAX, 0 // Null ?
      49. JZ @@New_Done
      51. PUSH EAX // Size
      52. PUSH ECX // Flags
      53. CALL @GlobalAlloc
      55. CMP EAX, 0 // Null ?
      56. JZ @@New_Done
      58. PUSH EAX // hMem
      59. CALL @GlobalLock
      61. @@New_Done:
      62. POP ECX
      63. ENDASM
      65. ' ********************
      66. ' Mem_Free() - Speicher freigeben
      67. ' bool% = Mem_Free( pMem& )
      68. ' Speicher freigeben
      69. ' Gibt den Speicherbereich auf den der Speicherzeiger zeigt wieder frei.
      70. ASM "Mem_Free", 1
      71. PUSH ECX
      73. MOV EAX, PAR1 // pMem
      75. CMP EAX, 0
      76. JZ @@Free_Done
      78. PUSH EAX // pMem
      79. CALL @GlobalHandle
      81. CMP EAX, 0
      82. JZ @@Free_Error
      84. MOV ECX, EAX
      86. PUSH ECX // hMem
      87. CALL @GlobalUnlock
      89. CMP EAX, 0
      90. JZ @@Free_Error
      92. PUSH ECX // hMem
      93. CALL @GlobalFree
      95. CMP EAX, 0
      96. JNZ @@Free_Done
      98. @@Free_Error:
      99. CALL @GetLastError
      101. @@Free_Done:
      102. POP ECX
      103. ENDASM
      105. ' ********************
      106. ' Mem_Size() - Größe des belegten Speichers ermitteln
      107. ' Size& = Mem_Size( pMem& )
      108. ' Ermittelt die Speichergröße auf die der Speicherzeiger zeigt.
      109. ' Liefert die Größe des Bereiches zurück.
      110. ASM "Mem_Size", 1
      111. PUSH ESI
      112. PUSH EDI
      114. XOR EDI,EDI
      115. MOV ESI, PAR1 // pMem
      117. CMP ESI, 0
      118. JZ @@Size_Done
      120. PUSH ESI // pMem
      121. CALL @GlobalHandle // --> hMem
      123. MOV ESI, EAX // hMem
      125. CMP EAX, 0
      126. JZ @@Size_Error
      128. PUSH ESI // hMem
      129. CALL @GlobalSize // size
      131. MOV EDI, EAX // size
      132. JNZ @@Size_Done
      134. @@Size_Error:
      135. CALL @GetLastError
      137. @@Size_Done:
      138. MOV EAX,EDI
      139. POP EDI
      140. POP ESI
      141. ENDASM
      143. ' ********************
      144. ' Mem_Clear() - Speicher mit Nullen überschreiben
      145. ' Size& = Mem_Clear( pMem& )
      146. ' Speicher mit Nullen beschreiben
      147. ' Der angegebene (gesamte) Speicherbereich wird mit binären Nullen überschrieben.
      148. ' Für eine Teilfüllung ist Mem_Fill() zu nutzen.
      149. ' benötigt Mem_Size(), "ZeroMemory"
      150. ' Ergebnis: Größe des überschriebenen Bereiches
      151. ASM "Mem_Clear", 1
      152. PUSH ESI
      154. XOR EAX, EAX
      155. MOV ESI, PAR1 // pMem
      157. CMP ESI, 0
      158. JZ @@Clear_Done
      160. PUSH ESI // pMem
      161. CALL @Mem_Size
      163. CMP EAX, 0 // size
      164. JZ @@Clear_Done
      166. PUSH EAX // size
      167. PUSH ESI // pMem
      168. CALL @RtlZeroMemory
      170. @@Clear_Done:
      171. POP ESI
      172. ENDASM
      174. ' ********************
      175. ' Mem_Fill() - Der angegebene belegte Speicherbereich wird mit Füllzeichen aufgefüllt.
      176. ' bool% = Mem_Fill( pMem&, Anzahl&, FüllChars$ )
      177. ' belegten Speicher füllen
      178. ' Ist Anzahl = 0 dann wird Anzahl auf Mem_Size(pMem) gesetzt.
      179. ' Der angegebene Speicherbereich wird mit Füllzeichen aufgefüllt.
      180. ' - ohne diese Angabe wird mit Chr$(0) aufgefüllt
      181. ' - bei einem Zeichen wird sys_FillMemory() genutzt
      182. ' - bei mehreren Zeichen wird sys_MoveMemory() genutzt
      183. ASM "Mem_Fill", 3
      184. PUSH ESI
      185. PUSH EDI
      186. PUSH ECX
      187. PUSH EBX
      188. PUSH EDX
      190. MOV ESI, PAR3 // FillChars
      191. MOV ECX, PAR2 // Anzahl
      192. MOV EDI, PAR1 // pMem
      193. MOV EBX, [ESI - 4] // Len(FillChars)
      195. PUSH EDI // pMem
      196. CALL @Mem_Size
      198. CMP ECX, EAX // Anzahl <= Size ?
      199. JNA @@Fill_Anz_Inside
      201. MOV ECX, EAX // neue Anzahl
      203. @@Fill_Anz_Inside:
      204. CMP ECX, 0 // Anzahl = 0 ?
      205. JZ @@Fill_Done
      207. CMP EBX, 1 // FillChars = Null or 1 ? (nein, dann Hauptstück)
      208. JA @@Fill_more
      210. // 1 Zeichen
      211. XOR EDX, EDX // Vorgabe ist Chr$(0)
      212. CMP ESI, 0 // FillChars = NullString ?
      213. JZ @@Fill_Start
      215. MOV DL, [ESI] // Nein, dann FillChar holen
      217. @@Fill_Start:
      218. // Bereich mit einem Zeichen füllen
      219. PUSH EDX // char
      220. PUSH ECX // Anzahl
      221. PUSH EDI // pMem
      222. CALL @RtlFillMemory
      223. JMP @@Fill_Done
      225. // --------------------
      226. @@Fill_more:
      227. CMP EBX, ECX // LEN( FillChars ) >= Anzahl ?
      228. JGE @@Fill_MoveOne
      230. // Da wir den Füllstring mehrmals schreiben wird die Länge benötigt
      231. PUSH EBX // Len(FillChars)
      233. // ----------
      234. @@Fill_Loop:
      235. CMP ECX, EBX // Anzahl < Len(FillChars)
      236. JGE @@Fill_Hop // Nein, weiter (sonst den Rest)
      238. POP EBX // Len(FillChars)
      239. MOV EBX,ECX // überschreibe mit Rest
      240. PUSH EBX // Rest
      242. @@Fill_Hop:
      243. PUSH EBX // Len(FillChars) (oder Rest)
      244. PUSH ESI // FillChars
      245. PUSH EDI // pMem
      246. CALL @RtlMoveMemory
      248. POP EBX // Len(FillChars)
      249. PUSH EBX // Len(FillChars)
      250. ADD EDI, EBX // pMem + Len(FillChars)
      251. SUB ECX, EBX // Anzahl - Len(FillChars)
      253. CMP ECX, 0 // Anzahl > 0
      254. JA @@Fill_Loop
      256. // --------------------
      257. // gesicherten Wert wieder entfernen
      258. POP EBX // Len(FillChars)
      259. JMP @@Fill_Done
      261. @@Fill_MoveOne:
      262. // Es sind mehr Füllzeichen als der Bereich groß ist.
      263. // Das läßt sich in einem Rutsch erledigen.
      264. PUSH ECX // Anzahl
      265. PUSH ESI // FillChars
      266. PUSH EDI // pMem
      267. CALL @RtlMoveMemory
      269. @@Fill_Done:
      270. POP EDX
      271. POP EBX
      272. POP ECX
      273. POP EDI
      274. POP ESI
      275. ENDASM
      277. ' ********************
      278. ' Mem_Move() - Speicherinhalte kopieren
      279. ' bool = Mem_Move( Ziel&, Quelle&, Anzahl& )
      280. ' Der angegebene Quellbereich wird in den Zielbereich kopiert.
      281. ' (Überlappungen von Quelle und Ziel sind hier erlaubt)
      282. ASM "Mem_Move", 3
      283. PUSH ESI
      284. PUSH EDI
      285. PUSH ECX
      286. //
      287. XOR EAX, EAX // 0 = es wurde nichts kopiert
      288. MOV ECX, PAR3 // Anzahl
      289. MOV ESI, PAR2 // pQuelle
      290. MOV EDI, PAR1 // pZiel
      291. //
      292. CMP ECX, 0 // Anzahl = 0 ?
      293. JZ @@Move_Done
      294. CMP ESI, 0 // Quelle = Null
      295. JZ @@Move_Done
      296. CMP EDI, 0 // Ziel = Null
      297. JZ @@Move_Done
      299. PUSH ECX // Anzahl
      300. PUSH ESI // pQuelle
      301. PUSH EDI // pZiel
      302. CALL @RtlMoveMemory
      304. @@Move_Ok:
      305. INC EAX // 1 = Kopieren wurde durchgeführt
      307. @@Move_Done:
      308. POP ECX
      309. POP EDI
      310. POP ESI
      311. ENDASM
      313. ' ********************
      314. ' Mem_Resize() - Speichergröße ändern/redimensionieren
      315. ' pMem& = Mem_Resize( pMem&, Size& )
      316. ' Speicher redimensionieren
      317. ' Ändert die Speichergröße auf die der Speicherzeiger zeigt.
      318. ' Die Größe des angegebenen Speicherbereiches wird auf die neue Größe geändert (wenn ungleich).
      319. ' Bei einer Vergrößerung des Bereiches bleiben alle Daten erhalten,
      320. ' bei einer Verkleinerung nur der vordere Teil. (!!!ohne Gewähr!!!)
      321. ' Liefert den neuen Speicherzeiger zurück.
      322. ASM "Mem_Resize", 2
      323. PUSH ECX
      324. PUSH ESI
      325. PUSH EDI
      327. MOV EDI, PAR2 // Size
      328. MOV ESI, PAR1 // pMem
      330. CMP ESI, 0 // Nullzeiger ? Dann Mem_New(Size)
      331. JZ @@Resize_New
      333. PUSH ESI // pMem
      334. CALL @GlobalHandle // --> hMem
      336. CMP ESI, 0
      337. JZ @@Resize_Error
      339. MOV ESI, EAX // hMem
      340. PUSH ESI // hMem
      341. CALL @GlobalSize // OldSize
      343. CMP EAX, 0 // Null
      344. JZ @@Resize_Error
      346. CMP EAX, EDI // OldSize = Size ? dann keine Größenänderung
      347. JZ @@Resize_Done
      349. PUSH ESI // hMem
      350. CALL @GlobalUnlock
      352. MOV EAX, 2 // GMEM_MOVEABLE = $2
      353. PUSH EAX // flags
      354. PUSH EDI // size
      355. PUSH ESI // hMem
      356. CALL @GlobalReAlloc
      357. MOV ESI, EAX // hMem
      359. CMP EAX, 0 // Null
      360. JZ @@Resize_Error
      362. PUSH ESI // hMem
      363. CALL @GlobalLock
      364. MOV ESI, EAX // pMem
      366. CMP EAX, 0 // Null
      367. JZ @@Resize_Error
      368. JMP @@Resize_Done
      370. @@Resize_New:
      371. PUSH EDI // Size
      372. CALL @Mem_New
      374. MOV ESI, EAX // pMem
      375. JMP @@Resize_Done
      377. @@Resize_Error:
      378. CALL @GetLastError // ohne Parameter
      380. @@Resize_Done:
      381. MOV EAX, ESI
      382. POP EDI
      383. POP ESI
      384. POP ECX
      385. ENDASM
      388. '$ENDIF
      390. Cls
      392. Declare long test1
      394. Print "Neu"
      395. test1 = Mem_New( 256 )
      396. Print "Adresse: "; test1
      397. Print " Größe: "; Mem_Size(test1)
      398. Mem_Free(test1)
      399. WaitInput
      400. FreeDLL mem_v_hDLL
      401. End
      Alles anzeigen
      Programmieren, das spannendste Detektivspiel der Welt.

    • Malwarebytes warnt !

      Michael
      Warum wird die PDF-Datei von meinem "MalwareBytes" geblockt ?

      An den Moderator:
      Die Frage ist vielleicht auch für die Mitglieder und XProfan-Nutzer interessant !

    • Für Fehlerbehandlung in Assembler-Routinen ist der Programmierer selbst verantwortlich. So kann man z.B. definieren, dass ein bestimmter Rückgabewert für einen Fehler steht. So machen es ja auch die Funktionen der Windows-API zum großen Teil. Der Wert in EAX ist immer der Rückgabewert. Auch bei API-Funktionen steht der Rückgabewert nach dem AUfruf in EAX. Natürlich kann der Rückgabewert auch ein Zeiger auf einen String oder einen Datenbereich sein.

      Globale Variablen als solche, die in verschiedenen Assemblerfunktionen gültig sind, gibt es naturgemäß nicht. Man kann sie aber relativ einfach simulieren, in dem man eine ASM-Funktion schreibt, die deren Wert zurückgibt. Diese kann dann von allen anderen ASM-Funktionen aufgerufen werden. (Windows handhabt das intern sehr ähnlich.) Du könntest also eine ASM-Funktion GetHWnd schreiben und schon könntest Du in allen weiteren Funktionen drauf zurückgreifen.

      Asssembler ist letztlich eine Hilfe um Maschinencode einzugeben (bestimmte merkbare Wörter entsprechen Op-Codes), keine wirkliche Programmiersprache, also auch nicht per se Prozedural oder Objektorientiert. Man kann allerdings ASM-Funktionen in Objekten verwenden und sogar erzeugen: Wenn man ASM-Funktionen für ein Objekt benötigt, sollte man sie im Constructor mit ASM...ENDASM erzeugen und kann sie dann in allen anderen Methoden des Objektes (genau genommen sogar im ganzen Programm) nutzen. Du könntest aus Deinen Funktionen also ein Objekt basteln, indem du sie alle im Konstruktor erzeugst und dann in den einzelnen Methoden des Objekts aufrufst. PMem würde ich dann als private Eigenschaft (etwa pmen&) der Klasse definieren, so dass alle Methoden darauf zugreifen können, es aber nach außen nicht sichtbar ist, es sei denn Du baust die entsprechende Getter-Methode (etwa getPMem) ein.

      Achtung: Derzeit fehlt noch die Überprüfung, ob es eine externe Funktion des Namens schon in der Funktionsliste gibt, bevor die neue hinzugefügt wird. Sie würde dann hinzugefügt werden und es wäre mehr oder weniger zufällig, welche der beiden beim Aufruf dann genutzt wird. Die Prüfung wird aber natürlich noch eingebaut!

      Gruß
      Roland
      Intel Duo E8400 3,0 GHz / 4 GB RAM / 1000 GB HDD / ATI Radeon HD4770 512 MB / Windows 7(32) - XProfan X4
      AMD Athlon II X2 2,9 GHz / 3 GB RAM / 500 GB HDD / ATI Radeon 3000 (onboard) / Windows 10(64) - XProfan X4

      http://www.xprofan.de

      Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von RGH ()

    • Hier Michaels Memory-Routinen als Klasse. (Einige Kommentare mussten weichen wegen des 10k-Limits im Forum.)

      Brainfuck-Quellcode: mem_asm.inc

      1. // MEM_ASM-Klasse
      3. CLASS MEM_ASM = #hMem&, \ ' Handle (Adresse) des erzeugten Speichers
      4. Mem_Asm@, \ ' Konstruktor aMem = New(Mem_Asm, Size) - Speicher belegen/reservieren
      5. Free@, \ ' Erfolg = aMem.Free( hMem ) - Speicher freigeben
      6. Size@, \ ' Size = aMem.Size( hMem ) - Größe des belegten Speichers ermitteln
      7. Clear@, \ ' Size = aMem.Clear( hMem ) - Speicher mit Nullen überschreiben
      8. Fill@, \ ' Erfolg = aMem.Fill( hMem, Anz, Fill ) - Der angegebene belegte Speicherbereich wird mit Füllzeichen aufgefüllt.
      9. Move@, \ ' Erfolg = aMem.Move( Ziel, Quelle, Anz ) - Speicherinhalte kopieren
      10. Resize@, \ ' Erfolg = aMem.Resize( hMem, Size ) - Speichergröße ändern/redimensionieren
      11. getHandle@ ' hMem = aMem.GetHandle () - Handle ermitteln
      13. Declare handle MEM_ASM.hDLL ' Klassenvariable
      15. Proc MEM_ASM.Mem_Asm // Konstruktor
      16. /***********************/
      17. Parameters long size
      19. MEM_ASM.hDLL = UseDLL("KERNEL32.DLL") ' Der Zähler für die DLL wird bei jedem Konstruktor erhöht und bei jedem Destruktor (Destroy) wieder erniedrigt
      21. If fAddr("Mem_New") = 0 // Der Code bis zum zugehörigen ENDIF wird nur beim allerersten Mal aufgerufen. Dann stehen die importierten Funktionen
      22. // und die mit ASM hinzugefügten Funktionen zur Verfügung
      24. ImportFunc( MEM_ASM.hDLL, "GetLastError", "" ) // GetLastError( )
      25. ImportFunc( MEM_ASM.hDLL, "GlobalAlloc", "" ) // GlobalAlloc( flags, Size )
      26. ImportFunc( MEM_ASM.hDLL, "GlobalFree", "" ) // GlobalFree( hMem )
      27. ImportFunc( MEM_ASM.hDLL, "GlobalHandle", "" ) // GlobalHandle( pMem )
      28. ImportFunc( MEM_ASM.hDLL, "GlobalLock", "" ) // GlobalLock( hMem )
      29. ImportFunc( MEM_ASM.hDLL, "GlobalReAlloc", "" ) // GlobalReAlloc( hMem, Size, flags )
      30. ImportFunc( MEM_ASM.hDLL, "GlobalSize", "" ) // GlobalSize( hMem )
      31. ImportFunc( MEM_ASM.hDLL, "GlobalUnlock", "" ) // GlobalUnlock( hMem )
      32. ImportFunc( MEM_ASM.hDLL, "RtlFillMemory", "" ) // FillMemory( pDest, Len, Char )
      33. ImportFunc( MEM_ASM.hDLL, "RtlMoveMemory", "" ) // MoveMemory( pDest, pSrc, Len ) 'Überlappung erlaubt
      34. ImportFunc( MEM_ASM.hDLL, "RtlZeroMemory", "" ) // ZeroMemory( pDest, Len )
      36. ASM "Mem_New", 1
      37. PUSH ECX
      38. MOV ECX, 66 // GMEM_MOVEABLE = 2 | GMEM_ZEROINIT = 64 | GMEM_PTR = 66
      39. MOV EAX, PAR1 // Size
      40. CMP EAX, 0 // Null ?
      41. JZ @@New_Done
      42. PUSH EAX // Size
      43. PUSH ECX // Flags
      44. CALL @GlobalAlloc
      45. CMP EAX, 0 // Null ?
      46. JZ @@New_Done
      47. PUSH EAX // hMem
      48. CALL @GlobalLock
      49. @@New_Done:
      50. POP ECX
      51. ENDASM
      52. ASM "Mem_Free", 1
      53. PUSH ECX
      54. MOV EAX, PAR1 // pMem
      55. CMP EAX, 0
      56. JZ @@Free_Done
      57. PUSH EAX // pMem
      58. CALL @GlobalHandle
      59. CMP EAX, 0
      60. JZ @@Free_Error
      61. MOV ECX, EAX
      62. PUSH ECX // hMem
      63. CALL @GlobalUnlock
      64. CMP EAX, 0
      65. JZ @@Free_Error
      66. PUSH ECX // hMem
      67. CALL @GlobalFree
      68. CMP EAX, 0
      69. JNZ @@Free_Done
      70. @@Free_Error:
      71. CALL @GetLastError
      72. @@Free_Done:
      73. POP ECX
      74. ENDASM
      75. ASM "Mem_Size", 1
      76. PUSH ESI
      77. PUSH EDI
      78. XOR EDI,EDI
      79. MOV ESI, PAR1 // pMem
      80. CMP ESI, 0
      81. JZ @@Size_Done
      82. PUSH ESI // pMem
      83. CALL @GlobalHandle // --> hMem
      84. MOV ESI, EAX // hMem
      85. CMP EAX, 0
      86. JZ @@Size_Error
      87. PUSH ESI // hMem
      88. CALL @GlobalSize // size
      89. MOV EDI, EAX // size
      90. JNZ @@Size_Done
      91. @@Size_Error:
      92. CALL @GetLastError
      93. @@Size_Done:
      94. MOV EAX,EDI
      95. POP EDI
      96. POP ESI
      97. ENDASM
      98. ASM "Mem_Clear", 1
      99. PUSH ESI
      100. XOR EAX, EAX
      101. MOV ESI, PAR1 // pMem
      102. CMP ESI, 0
      103. JZ @@Clear_Done
      104. PUSH ESI // pMem
      105. CALL @Mem_Size
      106. CMP EAX, 0 // size
      107. JZ @@Clear_Done
      108. PUSH EAX // size
      109. PUSH ESI // pMem
      110. CALL @RtlZeroMemory
      111. @@Clear_Done:
      112. POP ESI
      113. ENDASM
      114. ASM "Mem_Fill", 3
      115. PUSH ESI
      116. PUSH EDI
      117. PUSH ECX
      118. PUSH EBX
      119. PUSH EDX
      120. MOV ESI, PAR3 // FillChars
      121. MOV ECX, PAR2 // Anzahl
      122. MOV EDI, PAR1 // pMem
      123. MOV EBX, [ESI - 4] // Len(FillChars)
      124. PUSH EDI // pMem
      125. CALL @Mem_Size
      126. CMP ECX, EAX // Anzahl <= Size ?
      127. JNA @@Fill_Anz_Inside
      128. MOV ECX, EAX // neue Anzahl
      129. @@Fill_Anz_Inside:
      130. CMP ECX, 0 // Anzahl = 0 ?
      131. JZ @@Fill_Done
      132. CMP EBX, 1 // FillChars = Null or 1 ? (nein, dann Hauptstück)
      133. JA @@Fill_more
      134. // 1 Zeichen
      135. XOR EDX, EDX // Vorgabe ist Chr$(0)
      136. CMP ESI, 0 // FillChars = NullString ?
      137. JZ @@Fill_Start
      138. MOV DL, [ESI] // Nein, dann FillChar holen
      139. @@Fill_Start:
      140. // Bereich mit einem Zeichen füllen
      141. PUSH EDX // char
      142. PUSH ECX // Anzahl
      143. PUSH EDI // pMem
      144. CALL @RtlFillMemory
      145. JMP @@Fill_Done
      146. // --------------------
      147. @@Fill_more:
      148. CMP EBX, ECX // LEN( FillChars ) >= Anzahl ?
      149. JGE @@Fill_MoveOne
      150. // Da wir den Füllstring mehrmals schreiben wird die Länge benötigt
      151. PUSH EBX // Len(FillChars)
      152. // ----------
      153. @@Fill_Loop:
      154. CMP ECX, EBX // Anzahl < Len(FillChars)
      155. JGE @@Fill_Hop // Nein, weiter (sonst den Rest)
      156. POP EBX // Len(FillChars)
      157. MOV EBX,ECX // überschreibe mit Rest
      158. PUSH EBX // Rest
      159. @@Fill_Hop:
      160. PUSH EBX // Len(FillChars) (oder Rest)
      161. PUSH ESI // FillChars
      162. PUSH EDI // pMem
      163. CALL @RtlMoveMemory
      164. POP EBX // Len(FillChars)
      165. PUSH EBX // Len(FillChars)
      166. ADD EDI, EBX // pMem + Len(FillChars)
      167. SUB ECX, EBX // Anzahl - Len(FillChars)
      168. CMP ECX, 0 // Anzahl > 0
      169. JA @@Fill_Loop
      170. // --------------------
      171. // gesicherten Wert wieder entfernen
      172. POP EBX // Len(FillChars)
      173. JMP @@Fill_Done
      174. @@Fill_MoveOne:
      175. // Es sind mehr Füllzeichen als der Bereich groß ist.
      176. // Das läßt sich in einem Rutsch erledigen.
      177. PUSH ECX // Anzahl
      178. PUSH ESI // FillChars
      179. PUSH EDI // pMem
      180. CALL @RtlMoveMemory
      181. @@Fill_Done:
      182. POP EDX
      183. POP EBX
      184. POP ECX
      185. POP EDI
      186. POP ESI
      187. ENDASM
      188. ASM "Mem_Move", 3
      189. PUSH ESI
      190. PUSH EDI
      191. PUSH ECX
      192. //
      193. XOR EAX, EAX // 0 = es wurde nichts kopiert
      194. MOV ECX, PAR3 // Anzahl
      195. MOV ESI, PAR2 // pQuelle
      196. MOV EDI, PAR1 // pZiel
      197. //
      198. CMP ECX, 0 // Anzahl = 0 ?
      199. JZ @@Move_Done
      200. CMP ESI, 0 // Quelle = Null
      201. JZ @@Move_Done
      202. CMP EDI, 0 // Ziel = Null
      203. JZ @@Move_Done
      204. PUSH ECX // Anzahl
      205. PUSH ESI // pQuelle
      206. PUSH EDI // pZiel
      207. CALL @RtlMoveMemory
      208. @@Move_Ok:
      209. INC EAX // 1 = Kopieren wurde durchgeführt
      210. @@Move_Done:
      211. POP ECX
      212. POP EDI
      213. POP ESI
      214. ENDASM
      215. ASM "Mem_Resize", 2
      216. PUSH ECX
      217. PUSH ESI
      218. PUSH EDI
      219. MOV EDI, PAR2 // Size
      220. MOV ESI, PAR1 // pMem
      221. CMP ESI, 0 // Nullzeiger ? Dann Mem_New(Size)
      222. JZ @@Resize_New
      223. PUSH ESI // pMem
      224. CALL @GlobalHandle // --> hMem
      225. CMP ESI, 0
      226. JZ @@Resize_Error
      227. MOV ESI, EAX // hMem
      228. PUSH ESI // hMem
      229. CALL @GlobalSize // OldSize
      230. CMP EAX, 0 // Null
      231. JZ @@Resize_Error
      232. CMP EAX, EDI // OldSize = Size ? dann keine Größenänderung
      233. JZ @@Resize_Done
      234. PUSH ESI // hMem
      235. CALL @GlobalUnlock
      236. MOV EAX, 2 // GMEM_MOVEABLE = $2
      237. PUSH EAX // flags
      238. PUSH EDI // size
      239. PUSH ESI // hMem
      240. CALL @GlobalReAlloc
      241. MOV ESI, EAX // hMem
      242. CMP EAX, 0 // Null
      243. JZ @@Resize_Error
      244. PUSH ESI // hMem
      245. CALL @GlobalLock
      246. MOV ESI, EAX // pMem
      247. CMP EAX, 0 // Null
      248. JZ @@Resize_Error
      249. JMP @@Resize_Done
      250. @@Resize_New:
      251. PUSH EDI // Size
      252. CALL @Mem_New
      253. MOV ESI, EAX // pMem
      254. JMP @@Resize_Done
      255. @@Resize_Error:
      256. CALL @GetLastError // ohne Parameter
      257. @@Resize_Done:
      258. MOV EAX, ESI
      259. POP EDI
      260. POP ESI
      261. POP ECX
      262. ENDASM
      263. EndIf
      264. .hMem& = Mem_New(size)
      265. var int Ergebnis = 0
      266. if .hMem& > 0
      267. Ergebnis = 1
      268. EndIf
      269. EndProc
      271. Proc MEM_ASM.Free
      272. /***************/
      273. Var int Ergebnis = Mem_Free(.hMem&)
      274. FreeDLL MEM_ASM.hDLL
      275. Return Ergebnis
      276. EndProc
      278. Proc MEM_ASM.Size
      279. /***************/
      280. Return Mem_Size(.hMem&)
      281. EndProc
      283. Proc MEM_ASM.Clear
      284. /****************/
      285. Return Mem_Clear(.hMem&)
      286. EndProc
      288. Proc MEM_ASM.Fill
      289. /***************/
      290. Parameters long Anz, cFill
      291. Return Mem_Fill(.hMem&, Anz, cFill)
      292. EndProc
      294. Proc MEM_ASM.Move
      295. /***************/
      296. Parameters long ziel, Quelle, Anz
      297. Return Mem_Move(Ziel, Quelle, Anz)
      298. EndProc
      300. Proc MEM_ASM.Resize
      301. /*****************/
      302. parameters long size
      303. var int ergebnis = 0
      304. If Mem_Resize(.hMem&, Size)
      305. ergebnis = 1
      306. endif
      307. return ergebnis
      308. EndProc
      310. Proc MEM_ASM.getHandle
      311. /********************/
      312. Return .hMem&
      313. EndProc
      Alles anzeigen
      Intel Duo E8400 3,0 GHz / 4 GB RAM / 1000 GB HDD / ATI Radeon HD4770 512 MB / Windows 7(32) - XProfan X4
      AMD Athlon II X2 2,9 GHz / 3 GB RAM / 500 GB HDD / ATI Radeon 3000 (onboard) / Windows 10(64) - XProfan X4

      http://www.xprofan.de

    • Und hier ein Beispielprogramm dass diese Klasse nutzt:

      Quellcode

      1. $I MEM_ASM.INC
      2. Cls
      4. Print "Neu"
      5. Var mem aMem = New(MEM_ASM, 256)
      6. Print "Adresse: "; aMem.getHandle()
      7. Print " Größe: "; aMem.Size()
      8. Var mem aMem2 = New(MEM_ASM, 1024)
      9. Print "Adresse: "; aMem2.getHandle()
      10. Print " Größe: "; aMem2.Size()
      11. aMem.Free()
      12. aMem2.Free()
      14. WaitInput
      15. End
      Alles anzeigen
      Intel Duo E8400 3,0 GHz / 4 GB RAM / 1000 GB HDD / ATI Radeon HD4770 512 MB / Windows 7(32) - XProfan X4
      AMD Athlon II X2 2,9 GHz / 3 GB RAM / 500 GB HDD / ATI Radeon 3000 (onboard) / Windows 10(64) - XProfan X4

      http://www.xprofan.de

    • auch wenn die Bezeichnung nicht ganz stimmt... (New gibt einen Zeiger zurück, das Handle war für die Zwischenarbeiten)

      :oops: Auf die Idee, das Ganze dann einfach in XProfan einzuwickeln bin ich nicht gekommen...


      @Neuer Gast:
      Erstens habe ich hier keine PDF hochgeladen und zweitens: Wer macht sich die Mühe etwas in einer PDF zu verstecken. Das ist doch von übergestern.
      Programmieren, das spannendste Detektivspiel der Welt.

    • Hier mal ein kleiner Hexdump. Die Ausgabe erfolgt in der Listbox. Der ASM-Code ist zwar noch verbesserungswürdig, aber immerhin das Schnellste an dem Progrämmchen ;-)

      Quellcode

      1. Declare Mem Quelle, Ziel
      2. Declare String Datei
      3. Declare Handle hFile
      4. Declare Int DateiLaenge, ZLaenge, Zeilen, ZielGross, Gelesen
      6. ASM "Hexe", 5
      7. push ebx
      8. push ecx
      9. push edx
      10. push edi
      11. push esi
      12. mov esi, Par1 // Parameter 1: Quellbereich
      13. mov edi, Par2 // Parameter 2: Zielbereich
      14. mov ecx, Par3 // Parameter 3: QuellLänge
      15. mov edx, Par4 // Parameter 4: AusgabeLänge (Zeilenlänge üblicherweise 16 oder mitunter
      17. auch 8)
      18. mov eax, Par5 // Parameter 5: Anzeigeadresse der ersten Zeile
      19. mov [@@Adresse], eax
      20. mov [@@ZLang], edx
      21. // wenn als Zielbereich 0 gesetzt wird, wird nichts ausgeführt und anhand der QuellLänge
      22. // und AusgabeLänge wird die notwendige Mindestgröße für den Zielbereich berechnet und
      24. zurückgegeben
      25. or edi, edi
      26. jz @@MC
      27. jmp @@Begin
      28. // ein direkter Sprung JNZ @@SizeCalc ist zu lang
      29. // ebenso wie die Umkehrung JNZ @@Begin
      30. // deshalb dieser relative Sprung über einen JMP
      31. @@MC:
      32. jmp @@SizeCalc
      34. @@Zeile:
      35. dd 0
      36. @@ZLang:
      37. dd 0
      38. @@Adresse:
      39. dd 0
      41. @@AsciiZeile: // gibt die Eingabe als Text aus und ersetzt besondere Zeichen durch einen
      43. Mittelpunkt
      44. mov esi, [@@Zeile]
      45. @@AsciiByte:
      46. lodsb
      47. cmp al, $5e
      48. jz @@NoChar
      49. cmp al, $60
      50. jz @@NoChar
      51. cmp al, $a8
      52. jz @@NoChar
      53. cmp al, $b4
      54. jz @@NoChar
      55. cmp al, 31
      56. jg @@AsciiOut
      57. @@NoChar:
      58. mov al, $b7
      59. @@AsciiOut:
      60. stosb
      61. dec edx
      62. jnz @@AsciiByte
      63. ret
      65. @@Conv: // Konvertiert ein Nibble
      66. and al, $0f
      67. add al, $30
      68. cmp al, $3a
      69. jl @@NibOk
      70. add al, 7
      71. @@NibOk:
      72. ret
      74. @@ConvByte: // Konvertiert ein Byte
      75. push eax
      76. shr al, 4
      77. call @@Conv
      78. stosb
      79. pop eax
      80. call @@Conv
      81. stosb
      82. ret
      84. @@LongConv: // Konvertiert einen Long
      85. mov al, [esi + 3]
      86. call @@ConvByte
      87. mov al, [esi + 2]
      88. call @@ConvByte
      89. mov al, [esi + 1]
      90. call @@ConvByte
      91. mov al, [esi]
      92. call @@ConvByte
      93. ret
      95. @@AdrOut: // Gibt die Adresse hexadezimal zu 8 Zeichen Länge aus
      96. push esi
      97. mov esi, @@Adresse
      98. @@NextAdr:
      99. call @@LongConv
      100. mov al, 32
      101. stosb
      102. stosb
      103. mov eax, [@@Adresse]
      104. add eax, edx
      105. mov [@@Adresse], eax
      106. pop esi
      107. ret
      109. @@Begin:
      110. cld
      111. mov [@@Zeile], esi // notiert aktuellen Zeilenbeginn in der Quelle
      112. call @@AdrOut // Quelladresse ausgeben
      113. @@Zeichen:
      114. lodsb
      115. call @@ConvByte
      116. mov al, 32
      117. stosb
      118. dec edx
      119. jnz @@InZeile // in aktueller Zeile verbleiben
      120. // oder Zeilenschaltung einfügen
      121. mov edx, [@@ZLang]
      122. call @@AsciiZeile // hier ASCII-Interpretation
      123. mov al, 13
      124. stosb
      125. mov al, 10
      126. stosb
      127. mov edx, [@@ZLang]
      128. mov [@@Zeile], esi // notiert neuen Zeilenbeginn in der Quelle
      129. call @@AdrOut // Quelladresse für neue Zeile ausgeben
      130. @@InZeile:
      131. dec ecx
      132. jnz @@Zeichen // Ausgabelänge noch nicht erreicht
      133. // Restlänge der letzten Zeile steht in EDX
      134. or edx, edx
      135. jz @@NoRest
      136. push edx
      137. mov al, 32
      138. @@RestFill:
      139. stosb
      140. stosb
      141. stosb
      142. dec edx
      143. jnz @@RestFill
      144. pop edx
      145. mov eax, [@@ZLang]
      146. cmp eax, edx
      147. jz @@NoRest
      148. sub eax, edx
      149. mov edx, eax
      150. call @@AsciiZeile
      151. @@NoRest:
      152. mov al, 13
      153. stosb
      154. mov al, 10
      155. stosb
      156. xor eax, eax
      157. stosb
      158. jmp @@Raus
      159. @@SizeCalc: // Berechne Speichergröße für Ausgabe
      160. push edx
      161. mov eax, ecx
      162. mov ecx, edx
      163. xor edx, edx
      164. idiv ecx
      165. inc eax // Anzahl Zeilen
      166. mov ecx, eax // Anzahl Zeilen nach ECX
      167. pop eax // Zeilenlänge
      168. add eax, eax
      169. add eax, eax
      170. add eax, 12
      171. mul ecx
      172. add eax, 4
      173. @@Raus:
      174. pop esi
      175. pop edi
      176. pop edx
      177. pop ecx
      178. pop ebx
      179. EndASM
      182. CLS
      183. ZLaenge = 16
      184. Datei = LoadFile$("Datei wählen", "C:\*.*")
      185. If Datei <> ""
      186. hFile = Assign(Datei)
      187. OpenRW hFile
      188. Dateilaenge = GetFileSize(hFile)
      189. DIM Quelle, DateiLaenge
      190. ZielGross = Hexe(Quelle, 0, DateiLaenge, ZLaenge, 0) ' Zielspeichergröße berechnen lassen und
      192. dimmen
      193. DIM Ziel, ZielGross
      194. Gelesen = BlockRead(hFile, Quelle, 0, DateiLaenge)
      195. Close hFile
      196. Hexe(Quelle, Ziel, DateiLaenge, ZLaenge, 0) ' Hexdump erzeugen
      197. Move("MemToList", Ziel, "\n")
      198. ListBox$("Hexdump", 2)
      199. Dispose Quelle, Ziel
      200. EndIf
      201. Print "Fertig"
      203. WaitInput
      204. End
      Alles anzeigen

      HEXE wird mit 5 Parametern aufgerufen:
      1. Bereichsvariable, in der die Quelldaten stehen
      2. Bereichsvariable, die das Ergebnis aufnehmen soll
      3. Anzahl Bytes im Quellbereich
      4. Länge einer Ausgabezeile, üblicherweise 16 oder mitunter auch 8
      5. Anzeigeadresse für die erste Zeile


      Wird in 2 anstelle einer Bereichsvariablen der Wert 0 angegeben, wird die notwendige Mindestgröße für diesen Bereich berechnet und zurückgegeben. Damit kann dann die Bereichvariable gedimmt und anschließend die Funktion nochmals mit der Adresse des Bereiches aufgerufen werden.

      Gruß Volkmar

      Dieser Beitrag wurde bereits 2 mal editiert, zuletzt von Volkmar ()