Beiträge von DOheim

Außer "Zeile" waren ja alle Variablen in meinem Programm nicht notwendig. Ich habe sie eigentlich nur eingeführt, damit das Programm besser lesbar ist. Und statt "Zeile" habe ich einfach xmm1 verwendet. Übrigens habe ich über diese xmmi-Register nirgendwo etwas gefunden. Ich habe es mir einfach bei Dir abgeguckt. Es scheint so zu sein, dass sie nur mit anderen Registern korrespondieren können (z.B.: mov xmm1,eax), nicht aber mit Speichzellen (z.B.: mov xmm1,0 bzw. mov xmm1,[eax]).

Zitat von Andy

Vielleicht hast du ja noch andere Scripte / Programm(teil)e, in denen man etwas beschleunigen könnte

Das Farben einsammeln war ja bisher erst der erste Teil. Nun kommt noch das Einfügen der veränderten Farben. Und das verbraucht bisher noch mehr Zeit. Aber wahrscheinlich muss ich mich jetzt erst einmal um den Umstieg auf Win10 kümmern. Im Sommer habe ich dafür dann keine Zeit mehr (Garten).

Zitat von Andy

Ich sehe an deinem Code, du bist ( wieder?! ) mit dem ASM-Virus infiziert...das freut mich

Das habe ich aber nur dem hervorragenden Lehrgang, den ich bei Dir "besucht" habe zu verdanken. Schließlich war ich ja vom Embedding-Assembler völlig unbeleckt, als ich das Thema Assembler aufgesetzt hatte. Anhand dieser beiden Themen "Assembler" und "Assembler-Fortsetzung" kann jetzt jeder, der es möchte, in die Ass-Programmierung einsteigen.
Nochmals vielen Dank dafür!

Recht vielen Dank Andy für Deine so ausführliche Antwort.
Jetzt werde ich es in den Griff bekommen.
Nein, das ist nur eine kleine Bitmap-Datei, mit der ich den Algorithmus getestet habe.
Es wird bestimmt nicht meine letzte Frage gewesen sein.
Nochmals herzlichen Dank!
Gruß
Dieter

Hallo Andy,
ich möchte mein Assemblerprogramm in mein Bitmap-Programm einfügen und über DLLCallAdress aufrufen.
Test1.zip
Aber ich scheitere wenn ich die Zeile 243 aktiviere:
$binarycode ="0x8B7C240483C7368 ..."
Bei Deinem Programm ( siehe 16.1.16, 12:22) klappt das, aber bei mir nicht.
Was mache ich falsch?

Total gut !!!

Hallo Andy,
das werde ich mir zu Gemüte ziehen.
Vielen Dank
Dieter

PS: Es ist ja der reine Wahnsinn. Innerhalb von 42 ms hat das Programm einen 2,5 MByte Screenshot ausgewertet.
Da werde ich eine ganze Passage verwenden können. Eigentlich wollte ich ja mühselig das ASS-Programmieren lernen. Aber wenn es einem so leicht gemacht wird, siegt natürlich der innere Schweinehund.

Vielen Dank für Deinen Hinweis. Mein Bitmap-Programm habe ich ja schon lange fertig, und es klappt auch sehr gut. Aber es dauert eben so lange. Ich muss lediglich zwei Passagen durch ASS ersetzen. Seine Funktion hatte ich ja am 14. Dezember 2015 unter Assembler kurz vorgestellt.

In meinem oben am Mittwoch, 17:02, eingestellten Programm habe ich entsprechend Deinem Hinweis "str*" statt "str" geschrieben. Aber _ASMDBG_() zeigt mir dann im Register ebx alles andere als meine String-Bytes an. Habe ich da etwas falsch verstanden?

PS: Jetzt habe ich es kapiert: "str*" erzeugt die Adresse der Adresse des Strings.

Recht vielen Dank!
Du hast Dich ja schon sehr intensiv mit der Materie beschäftigt.
Jetzt habe ich ja eine Menge "Handwerkszeug" zur Verfügung.
Wie gesagt: Jetzt geht es erst einmal ans "Verdauen".
Nochmals vielen Dank
von Dieter

Hallo Andy,
recht vielen Dank für Deine ausführlich Antwort.
Das wird mir sehr weiterhelfen. Schön ist es, dass Du zu jedem Problem immer ein passendes und anschauliches Musterprogramm mitschickst. Und ohne den prima Debugger würde ich ohnehin immer völlig im Dunkeln stehen.
Jetzt muss ich alles erst einmal verdauen.

Zitat von Andy

Die Frage ist, wo Strings mit enthaltenen Nullbytes herkommen, deren Vorkommen in der freien Wildbahn ist SEHR begrenzt! IdR. sind das sowieso BYTE Structs, daher sollte man diese auch so behandeln!

Auf diese Weise will ich die eingelesene Bitmap-Datei dem Assemblerprogramm zugänglich machen. Und Bitmap-Dateien haben ja naturgemäß jede Menge Nullbytes.
Bis bald Gruß Dieter

PS: noch eine weitere Frage:
Wie kann ich in meinem Assemblerprogramm einen zusammenhängenden Speicherbereich bestimmter Größe reservieren?

Fortsetzung von:
Link
---------------------------------------------------------------------

Ich habe die folgenden beiden Probleme

1. Problem

Wie kann ich _AssembleIt2 einen String zugänglich machen, welcher Nullbytes beeinhaltet?
Mit folgendem Programm

#include <assembleit2_64.au3>


#cs _numberofpixel
    use32
    org $PTR_SOURCE_ASMCODE ;only needed for assembleit debugger


    mov edi,[esp+4]                       ;pointer
    mov ecx,[esp+8]                       ;anzahl
    _ASMDBG_()            ;debug-gui anzeigen
    mov eax,0
    _next:
    mov ebx,[edi+eax]
    _ASMDBG_()            ;debug-gui anzeigen
    add eax,1                             ;next pixel
	cmp eax,ecx
    jne _next


    ret                                   ;return, returns eax
#ce


; $string="1234567890"
$string="123"&Chr(0)&"4567890"
$len=StringLen($string)
Local $ret = _AssembleIt2("uint", "_numberofpixel", "str", $string, "int", $len)

erfolgt dieser Abbruch:

Der Inhalt kann nicht angezeigt werden, da er nicht mehr verfügbar ist.

Ersetze ich in assembleit2_64.au3 die Zeile

If Eval("Type" & $n) <> "" Then $scriptstring &= ",'" & Eval("Type" & $n) & "'," & Eval("Param" & $n)

durch die Zeile

If Eval("Type" & $n) <> "" Then $scriptstring &= ",'" & Eval("Type" & $n) & "'," & "$Param" & $n

erfolgt zwar kein Abbruch, jedoch werden dem Assemblerprogramm nur die ersten drei Zeichen (bis zum Nullbyte) zur Verfügung
gestellt.
Am besten wäre es meines Erachtens, wenn man die Adresse des Strings ermittel könnte und diese dann dem Assemblerprogramm zur
Verfügung stellen könnte. Aber wie ermittle ich die Adresse eines Strings?

2. Problem


Wenn das Assemblerprogramm als Ergebnis ein Feld erarbeitet, wie kann ich das dem aufrufenden Autoit-Programm zur Verfügung stellen?


Vielen Dank schon einmal für eine Antwort !

Danke Oscar, es klappt!

Ich hatte mich schon gewundert:

Ich hatte sowohl hinter dem Befehl
mov eax,0 ;counter pixel with Color
als auch hinter dem Befehl
cmp ebx,[edi+ecx*4] ;is dword=color ? (4 Bytes per pixel)
je einen Debuggeraufruf _ASMDBG_() eingefügt.
Der erste wurde angezeigt und bevor der zweite kam schmierte das Programm ab.
Eigentlich hätte ich das genauer untersuchen müssen.
Aber ich habe gedacht, dass ich - als Assemblereinsteiger - etwas falsch gemacht habe.

Und Andy muss sich wirklich nicht innerlich zerfleischen. Ein Programmierer, der keine Fehler macht, wäre ein Monster.
Jedenfalls werden mir die Programmbeispiele von Andy und auch von Marc sehr bei meinem Studium des X86-Assemblers sehr helfen.
Bestimmt komme ich bald mit weiteren diesbezüglichen Fragen. Dann werde ich aber ein neues Thema aufmachen.

Ich möchte mich sehr bei Euch dreien bedanken!

Zitat von Andy

Kommentiere mal die Zeilen mit $ret = _AssembleIt2(blablub)
und die darauffolgende Consolewrite aus, so dass nur der Dllcall übrig bleibt, alle Sleeps auskommentieren.
Funktioniert das?

Funktioniert nicht. Siehe Sreenshot1
Link: https://autoit.de/index.php/Atta…creenshot1-JPG/

Aktiviere ich aber den Sleep BBB dann geht es. Siehe Sreenshot2
Link: https://autoit.de/index.php/Atta…creenshot2-JPG/
Allerdings ist die Anzahl Pixel =0:

DllCallAddress() Anzahl Pixel = 0 Zeit [ms] = 2.147

Zitat von Andy

Wenn es also am Aufruf von _AssembleIt() liegt, bitte mal ganz oben im Assemblercode nach dem Use32 ein RET eintragen, dann nochmal testen, immer noch ohne die Sleeps.

Funktioniert. Siehe Sceenshot3
Link: https://autoit.de/index.php/Atta…creenshot3-JPG/

Auch wenn ich _AssembleIt2() und die 3 Sleeps wieder aktiviere, kommt Anzahl Pixel = 0

_AssembleIt2() Anzahl Pixel = 0 Zeit [ms] = 3.817
DllCallAddress() Anzahl Pixel = 0 Zeit [ms] = 1.88

Übringens klappt es auch mit den drei Sleep nicht immer.

Rätselhaft!

Du wirst Dich wundern, wie ich auf die Sleeps gekommen bin. Ich hatte zunächst an diesen drei Stellen MsgBox-Befehle gestellt. Und da ging es. Eigentlich haben die ja nichts anders bewirkt, als das Programm zu verzögern.

Noch eine andere Frage. Es gibt Foren, da bekommt man eine E-Mail, wenn eine neue Antwort eingetroffen ist. Kann man das hier auch einrichten. Was haben eigentlich die Abbonierten Themen für einen Zweck?

Als Link zu dem Screenshot funktionieret dieser:
https://autoit.de/index.php/Atta…creenshot6-JPG/

Übrigens dauert es zwischen den Zeilen:

@@ Debug(48) : $col = FF000000
>Error code: 0

und:

!>10:56:48 AutoIt3.exe ended.rc:-1073741819

ein paar Sekunden. Also irgend etwas macht er.

AutoIt-Version: Stabil 3.3.12.0 (Stand 17.9.14)

Betriebssystem: Windows 7

Durch
#AutoIt3Wrapper_UseX64=n
ändert sich nichts.

Bin als Administrator eingeloggt. Habe in dieser Hinsicht auch sonst keine Schwierigkeiten.
Dein Beispiel "Debugger Beispiele.au3" funktioniert ja auch einwandfrei.
Auch die Beispiele "Beispiel_1 ASM-Code AssembleIt2 Farbpalette.au3" usw. funktionieren.

Gruß
Dieter

PS.:
Ich habe mal drei Sleep-Befehle eingefügt.
Jetzt klappt es:
screenshot2.JPG
Link: https://autoit.de/index.php/Atta…creenshot2-JPG/
Woran mag das wohl liegen?
Nochmals herzlichen Gruß

Hallo Andy und Mars,
zunächst vielen Dank für die Mühe, die Ihr Euch mit mir gebt.
Zu dem Beispiel von Andy:
Ich bekomme es einfach nicht zum Laufen. Ich habe Verschiedenes herumexperimentiert, aber es läuft immer darauf hinaus wie im Screenshot dargestellt.

Der Inhalt kann nicht angezeigt werden, da er nicht mehr verfügbar ist.

Die beiden
- ConsoleWrite ('@@ Debug ...
erscheinen, aber
- ConsoleWrite("_AssembleIt2() ...
nicht mehr und das Program bricht mit einem Fehler ab..
Gestartet habe ich das Programm über Tools/Go. Ich habe es auch kompiliert und dann gestartet, das klappt aber auch nicht.
Problem ist, dass ich bisher nicht mit WinApi- und Dll-Funktionen gearbeitet habe, und es mir schwer fällt, alles so richtig zu kapieren.
Was habe ich falsch gemacht? Vielleicht kannst Du mir auf die Sprünge helfen.

Lieber Andy,

Zitat von Andy

Wenn du das Scriptfenster von Scite so verkleinerst, dass es neben das Debugfenster passt, wirst du feststellen, dass bei jedem _ASMdebug_() im ASM-code in die entsprechende Zeile in Scite gesprungen wird...

Das war mir gleich aufgefallen. Total gut!

Zitat von Andy

Was willst du machen bzw. wozu Assembler in Kombination mit AutoIt?

Ich habe vor längerer Zeit ein Bitmap-Programm geschrieben, das mehrere Aufgaben erfüllt.
Alles funktioniert zur Zufriedenheit. Aber die eine Aufgabe dauert ewig:
An einem Mini-Beispiel erläutert:
Ich habe diese Bitmap:
aaa1.bmp
Das Programm ermittelt nun alle vorkommenden Farben (auf Wunsch auch Farbbereiche) und zeigt sie so an:
aaa2.bmp
Nun kann man nach belieben Farben verändern.
Und dieser ganze Prozess (in AutoIt geschrieben) dauert bei großen Bitmaps recht lange.
Die ganze Organisation rundherum macht sich mit AutoIt recht gut, aber das Filetstück mit der Bearbeitung von Millionen Bitmap-Pixeln möchte ich mit Assembler lösen.

Kannst Du mir einen Tipp geben, wo ich ein Verzeichnis der möglichen Parameter-Typen für die Funktion _AssembleIt2 finde.
"int_ptr" scheint ja eine ganze Zahl zu bedeuten.
Was müsste man angeben, wenn man den Inhalt einer Bitmap-Datei als String (den man mit FileRead gelesen hat) übergeben möchte?

Vielen Dank Euch beiden, Andy und Mars!

Jetzt habe ich ja reichlich Material für mein Assembler-Studium.

Wie kann man denn erkennen, dass z.B. elitepvpers eine schädliche Seite ist?
Hat diese etwa auf meinem PC schon einen Schaden angerichtet?
Dann müsste ich mir meinen letzten System-Backup zurückholen.

PS.: Der Debugger ist ja eine feine Sache!

Erst einmal recht herzlichen Dank für Deine Antwort.
Dein FASM klapp ja prima. So habe ich jedenfalls erst einmal das Beispiel

#include <FASM.au3>
$zahl1=Inputbox("Zahl","Zahl1")
$zahl2=Inputbox("Zahl","Zahl2")
$Fasm = FasmInit()
FasmReset($Fasm)
FasmAdd($Fasm, "use32")
FasmAdd($Fasm, "mov eax, [esp+4]")
FasmAdd($Fasm, "mov edi, [esp+8]")
FasmAdd($Fasm, "add eax, edi")
FasmAdd($Fasm, "ret")
$bytecode=FasmGetBinary($Fasm)
$tCodebuffer=dllstructcreate("byte["&stringlen($Bytecode)/2-1&"]")
dllstructsetdata($tCodeBuffer,1,$Bytecode)
$Ret= DllCall("user32.dll", "int", "CallWindowProcW", "ptr", DllStructGetPtr($tCodeBuffer), "int", $zahl1, "int", $zahl2, "int", 0, "int", 0)
MsgBox(0,"Ergebnis",$Ret[0])

von
[Link entfernt]

zum Laufen bekommen. Jetzt muss ich mir das allerdings alles erst einmal zu Gemüte ziehen.
Ich habe in den 60er, 70er und 80er Jahren nur mit Assembler gearbeitet. Die "Großrechner" hatten einen gegenüber unseren PCs so geringe Arbeitsspeicher (1963: 2K Bytes, 1972: 64K Bytes), dass man mit jedem Byte geizten musste und keine höhere Sprache verwenden konnte. Ja und jetzt muss ich mit der Ass-Programmierung ganz von vorne anfangen. Aber um mit Bitmaps (mit beispielsweise 3 MByte) zu arbeiten, kommt man um Ass nicht herum.
Bestimmt werde ich bald mit weiteren Fragen kommen.
Also nochmals vielen Dank!

Edit Oscar: Link entfernt. Bitte keine Links zu Botforen!

Drei Fragen:
1. Wo finde ich <ASM.au3> und <FASM.au3> ?
2. Worin besteht der Unterschied zwischen beiden?
3. Wo finde ich eine Beschreibung der Assemblerbefehle, die ich hier verwenden kann?
Schon einmal recht vielen Dank für eine Antwort.

Mir ging es ja um die Registerkarten.

Ich habe beispielsweise mehrere IE-Instanzen (IE-Prozesse) gestartet mit jeweils mehreren Registerkarten.
Kann ich herausfinden ob sich darunter eine bestimmte - von mir gesuchte - Registerkarte (Titel und/oder Adresse) befindet, ohne die einzelnen IE-Instanzen zu aktivieren (z.B. mit WinActivate)?

Recht vielen Dank Micha_he und Darnas !
Als ich Micha_he's Programm gestartet hatte, kam ein Hinweis, dass bei einem 64-Bit-System auch die 64-Bit-Variante zu starten ist. Das hat mich stutzen lassen!!!
Zu Beginn der Compilierung im Wrapper-Fenster hatte ich nur den Haken bei X64 gesetzt, aber den bei X86 nicht entfernt.
Und nun klappt alles.
Recht herzlichen Dank nochmals!
Gruß Dieter

#Region ;**** Directives created by AutoIt3Wrapper_GUI ****
#AutoIt3Wrapper_UseX64=y
#EndRegion ;**** Directives created by AutoIt3Wrapper_GUI ****
#include <GuiListView.au3>
Local $arr[300][3]
If Not WinActive("Program Manager") Then WinActivate("Program Manager")
$hwnd = ControlGetHandle("Program Manager", "", "SysListView321")
$hwnd = HWnd($hwnd)
For $i = 0 To _GUICtrlListView_GetItemCount($hwnd) - 1
$arr[$i][0] = _GUICtrlListView_GetItemText($hwnd, $i)
$pos = _GUICtrlListView_GetItemPosition($hwnd, $i)
$arr[$i][1]=$pos[0]
$arr[$i][2]=$pos[1]
Next
_ArrayDisplay($arr)