Gewöhnungsbedürftig, aber gefällt mir^^
Man könnte die aktuelle Cursorposition abfragen, und dort Code einfügen. Weiterhin wäre schön, kontextsensitiv die Buttons zu zeigen, bzw auszugrauen.
Bei einer Liste wäre dann nur "Neue Liste" anklickbar, denn "Neuer Listeneintrag" und "Liste Ende" bräuchte man nicht.
Weiterhin sind die Buttons relativ unübersichtlich, wenn man die Gruppiert und bissl "schöner" anordnet, gibt das wesentlich " mehr her" und steigert auch die Usability 
Und hinzu kommt das ich mich mit Array überhaupt nicht auskenn, nicht mal weiß was das ist
Ein Array ist nichts aufregendes, nur eine "Sammlung" von Daten, auf die mit einem Index zugegriffen wird. Wie in einer Pizzeria, wenn du die Nummer 5 bestellst, dann backt dir der Pizzabäcker nicht eine 5, sondern eine Pizza mit Salami, Käse und Schinken.
Das Array wäre in dem Fall die Speisekarte, die Nummern der jeweilige Index des Arrays, und die Gerichte der Wert oder der Inhalt des Arrayelementes.
dim $Pizza_array[Anzahl der Gerichte]
$Pizza_array[1]="Pizza Tomaten und Käse"
$Pizza_array[2]="Pizza Sardellen und Thunfisch"
$Pizza_array[3]
...usw usf
um jetzt auf die Daten zuzugreifen, sprichst du das Array mit dem Index an.
filewrite($file, $Pizza_array[22]) ;schreibt die Zutaten füpr die Pizza Nummer 22 in eine Datei
[/autoit][autoit][/autoit][autoit]for $i=0 to ubound($Pizza_array)-1 ;alle Elemente im array
filewrite($file, $Pizza_array[$i] & @crlf) ;schreibt die Zutaten aller Pizzen in eine Datei
next
Wenn es keine Funktionen speziell für deinen Anwendungsfall gibt, dann musst du die Elemente des Arrays selbst auslesen und in eine Datei speichern. Bugfixens TUT sollte dir weiterhelfen (s.link oben)
Das Problem liegt m.E. darin, dass sich mehrere "Timestamp"-Formate etabliert haben. So lange man weiss , mit was man es zu tun hat ist alles paletti. Aber wehe, man trifft auf etwas unbekanntes, dann fängt, wie bei AutoBert, die Sucherei an. Ich habe da auch schon geflucht!
In einigen Jahren wird man die bisherige Zeit
Eine Sekunde ist das 9.192.631.770-fache der Periodendauer der dem Übergang zwischen den beiden Hyperfeinstrukturniveaus des Grundzustandes von Atomen des Nuklids 133Cs entsprechenden Strahlung.
Definitionsgemäß ist die Sekunde also das Vielfache der Periode einer Mikrowelle, die mit einem ausgewählten Niveauübergang im Caesiumatom in Resonanz ist. Daher wird sie als Atomsekunde bezeichnet. Atomuhren basieren auf der Messung dieses Übergangs.
erweitern auf die Anzahl dieser Schwingungen seit dem Urknall.
Das wird dann die "Universumszeit"
Irgendwie muss man ja die 1 Gigabit breiten Register der zukünftigen Rechner mit unwichtigemm Krempel verfüllen 
Ich öffne FASMW, kopiere den Text
format MZ ;exe bauen
push cs
pop ds ;aktuelles datensegment holen
mov ah,9h ;"Zeichenkette darstellen" Funktion int 21
mov dx, nachricht1 ;Adresse Nachricht1
int 21h
; massig code^^
mov ah,9h ;Funktion int 21
mov dx, nachricht2 ;Adresse Nachricht2
int 21h
mov ax,4C00h ;exit
int 21h
nachricht1 db 'Hallo, ich bin ein String!',13,10,13,10,'$' ;2x CRLF strings immer mit $ terminieren
nachricht2 db 'Huhu, die 2. Zeile!',13,10,'$'in den Editor, dann drücke ich CTRL+F9 fürs Compile, gebe ggf Dateinamen "TestEXE.exe" an, drücke den OK-Button des fensters mit den (nicht vorhandenen ^^) Fehlermeldungen weg.
Dann öffne ich eine CMD im Pfad der erstellten exe, gebe am Prompt testexe ein, enter und bekomme als Ausgabe die 2 Zeilen.
for $i=1 to $ordner[0]
DirCreate(@ScriptDir & '\' & $ordner[$i])
next
EDIT
<---den 1.Preis im "als zweiter Posten" beansprucht^^
Seltsam, bei dem von mir geposteten Script wird da nix drangehängt, auch stringlen($ret[0]) gibt 5 Buchstaben sowohl bei der Ver- als auch bei der Entschlüsselung zurück!
Und jetzt? Soll sich einer von uns durch hunderte Codezeilen wühlen, nur weil ihr dazu zu faul seid, einige Messageboxen zu plazieren und den "Übeltäter" selbst zu finden?
Wenn ein Scripteil kontinuierlich angeforderten Speicher nicht mehr frei gibt, dann würde ich den Taskmanager öffnen, alles anzeigen lassen was mit Speicher (und in diesem Fall mit GDI) zu tun hat und mich durch das Script hangeln.
Anfangen würde ich z.B. bei Funktionsaufrufen wie Capture2Tiff, eine Msgbox(0,"vor",0) davor, eine Msgbox(0,"nach",0) dahinter und dann den Speicherverbrauch im Taskmanager beobachten...so kreist man das Problem immer weiter ein. Das dauert zwar etwas, aber Fehler suchen dauert immer. Und man muss nicht seine eigene Arbeit von anderen erledigen lassen....
Das hört sich vielleicht etwas hart an, aber allein die Art und Weise der "Frage" bringt mich auf die Palme!
Man hätte den Thread ja auch folgendermassen starten können: "Die Funktion xxxx in der angehängten Tesseract-UDF verursacht beim DLLCALL (blablub) in Zeile 12345 einen Fehler, Speicher wird nicht mehr freigegeben, was ist an diesem Call falsch bzw was muss man ändern um Speicher frei zu geben?"
Dann hätte man gesehen, daß der Threadersteller sich schon selbst beschäftigt hat und das Problem wäre zumindest lokalisiert! Irgendein Spezialist guckt in das Codesegment und erkennt den Fehler bzw kann eine Lösung vorschlagen. Bugs FINDEN sollte jeder selbst können!
Iwie klappt das mit dem Twister der die Geschwindigkeitsunterschiede Zeigen soll bei mir nicht.
GDI+ packt 8-9, WinApi 20-22 und QD nur 7-8 also vergleichbar mit der GDI+
das liegt daran, daß _QuickDraw_Point(Pixel) ca. 4x langsamer ist als ein dllstructsetdata(Pixel). Um also einzelne Pixel zu modifizieren wäre es sinnvoller, OpenCl einzusetzen, um die Berechnungen der Farbe direkt auf der Graka durchzuführen.
Im Ausgleich dazu ist aber der OpenGl-Befehl zum Einblenden der Grafik (_Quickdraw_Swapbuffer) ca 10x schneller als ein BitBlt! Was allerdings den Kohl auch nicht sonderlich fett macht, denn auch BitBlt erreicht locker mehrere hundert FPS.
FichteFoll, wie du aus seinem geposteten Ergebnis beim _FTP_GetFileSize()-Beispielscript sehen kannst, werden ja die richtigen Ergebnisse (u.a. Dateigrößen) ermittelt!
Ich kann nur nicht ganz nachvollziehen, wieso er bei einer x-beliebigen Datei aus dem Internet richtige Dateigrößen erhält, und bei seinen eigenen Dateien nicht...
Weitere Optimierung am "Tunnelflug" am Beispiel eines Arrays bzw. LookUpTabelle LUT
Beim bisherigen "Tunnelflug" war ein Assemblerbefehl FPATAN() enthalten, um kartesische Koordinaten in Polarkoordinaten umzurechnen, siehe ATAN2
Allein dieser FPATAN() benötigt zur Ausführung bis zu 300 Takte, die Latency beträgt 136 Takte....was das bedeutet interessiert erstmal nicht, aber wenn man mal vergleicht, dass ein ADD in einem Takt ausgeführt wird, ist das ....hmpft..."etwas" viel!
Wenn man einfach die Zeile im Programm, in dem der FPATAN() Befehl steht, auskommentiert, erhöhen sich die Frames pro Sekunde auf über das Doppelte bis fast zum dreifachen!
Krass gesagt, EIN einziger Befehl frisst mehr als die Hälfte der Performance des Programms!
Genau an diesem Punkt fängt die Optimierung an. Man optimiert zuerst nicht am "Kleinkram", sondern immer an "den dicken Brocken"!
FPATAN() ist solch ein Brocken...
Wie kann man einen Prozessorbefehl verbessern?
Nun, der Coprozessor wendet allerfeinste Algorithmen an, um immer genau das richtige Ergebnis der Berechnung auszugeben.
Wir brauchen aber nicht die 30. Nachkommastelle genau, uns reichen 3-4 Nachkommastellen zum Anzeigen unserer Grafik.
Also legen wir (wenn BugFix keine Ohren hätte, würde er jetzt im Kreis grinsen^^) ein ARRAY an. Ein Array von Fließkommazahlen mit Tausend Elementen.
Das Array wird gefüllt mit den berechneten Ergebnissen von arcustangens(0) bis arcustangens von 10.
Also in AutoIt übersetzt
dim $atan_array[1000]
for $i=0 to 999
$atan_array[$i]=atan($i/100)
next
In Assembler legen wir das Array als eine Reihe von Dwords an, Tausend Stück!
FasmAdd($Fasm, "atantabelle dd 1000 dup 0") ;array mit 1000 werten für atantabelle[atanindex]=atanvalue erstellen
[/autoit]
Wie greift man auf den Inhalt eines Arrays zu? Mit dem Index!
Wir wissen von unserem "Assemblerarray" die Startadresse (atantabelle) und das jedes Element 4 Byte groß ist.
Um also auf das 7. Element zuzugreifen, rechnen wir
atantabelle(das ist die Startadresse) + 4 * 7 (7 ist der Index)
um also das 88. Element aus dem Array in das Register EAX zu befördern, schreibt man
mov EAX,[atantabelle + 4 * 88]
;oder per Indexregister
mov EBX,88 ;oder jedes andere Register
mov EAX,[atantabelle + 4 * EBX]
Genauso beschreibt man das Array
mov EBX,88 ;oder jedes andere Register
mov [atantabelle + 4 * EBX], EAX ;EAX in das Array eintragen
OK, wir haben nun ein Array, welches wir mit den Arcustangenswerten füllen können, was soll das nützen?
Wir müssen, wenn wir einen Wert aus der Tabelle bzw dem Array benötigen, nur den Index haben, um den passenden Wert auszulesen.
Der Index ist aber gerade das 100-fache unseres gesuchten arcustanges (schaut euch die FOR/TO Schleife im AutoItscript oben an)
Also nehmen wir unseren Wert von dem wir den arcustangens suchen, z.B. 0,55 , und nehmen den mal 100 und erhalten den Index 0,55*100=55
In der atantabelle bei Index 55 steht der arcustangens von 0,55....isn´t that easy? 
Der Witz ist nun, wir benötigen eine Multiplikation (mal 100), ein bissl Vorzeichengeplänkel, (-0,55 ergäbe einen Index von -55, und den gibts nicht) und einen Vergleich und haben unseren Index ermittelt
Ich habe nicht nachgezählt, aber mehr als 10-15 Takte sollte das alles nicht dauern. Aber 15 Takte zu 300 ist ein geschmeidiger Wert, wir können uns auf die Schulter hauen!
Bei der Berechnung eines jeden Pixels im Fenster sparen wir nun 285 Takte ein, bei 1000x1000 Pixel sind das läppische 285 Millionen Takte pro Frame....
Unser Programm ist zwar 50 Zeilen länger geworden und wir brauchen auch 4 Kilobyte mehr Speicher für das Array, aber die Ausführungsgeschwindigkeit hat sich verdoppelt!
50 Zeilen und +4kB um EINEN Befehl zu ersetzen? Nun ja...wir sind ja noch lange nicht fertig mit dem optimieren, da geht sicher noch was^^
#include <FASM.au3>
#include <MemoryDll.au3>
#include <WinAPI.au3>
#include <WindowsConstants.au3>
#include <StructureConstants.au3>
#include <GDIConstants.au3>
#include <array.au3>
#include <GUIConstantsEx.au3>
;im folgenden Beispiel wird der Befehl FPATAN() der ca 300 Takte braucht, durch einen schnellen Zugriff auf eine LookUp-Tabelle LUT ersetzt
;der Geschwindigkeitsgewinn beträgt ca. x2!
;die lookuptabelle ist ein Array mit dem Index von 0 bis 1000 und enthält die Werte atan(0) bis atan(10)
Opt("GUIOnEventMode", 1)
[/autoit] [autoit][/autoit] [autoit]$b=640 ;Breite und höhe in pixel
$h=640
global $Fasm = FasmInit(), $FPS
_createbytecode() ;assemblercode erstellen
;backbuffer erstellen für die Bitmap
local $ptr_bitmap,$hbmp_bitmap ;byref
$hDC_bitmap=_CreateNewBmp32($b, $h, $ptr_bitmap,$hbmp_bitmap) ;DC, Pointer auf die Bitmapdaten und ein Handle für GDI+....eine eierlegende Wollmilchsau
$hgui=guicreate("",$b,$h,1,1)
$hdc_gui=_WinAPI_GetDC($hgui)
guisetstate()
GUISetOnEvent($GUI_EVENT_CLOSE, "_Exit")
adlibregister("_fps",1000) ;FramesPerSecond
$step=0.02 ;das ist die Schrittweite, um die der Tunnelflug ein Frame weiter gezeichnet wird
[/autoit] [autoit][/autoit] [autoit]$struct_a=dllstructcreate("float") ;
dllstructsetdata($struct_a,1,$step) ;zähler, wird nach jedem Frame um $step erhöht
while 1;sleep(20)
$Ret = MemoryFuncCall("float", FasmGetFuncPtr($Fasm), "int", $b,"int",$h,"float",dllstructgetdata($struct_a,1),"ptr", $ptr_bitmap)
_winapi_bitblt($hdc_gui,0,0,$b,$h,$hDC_bitmap,0,0,$srccopy) ;bitmap in die GUI blitten
$fps+=1
dllstructsetdata($struct_a,1,dllstructgetdata($struct_a,1)+$step) ;zähler um step erhöhen
wend
func _fps()
winsettitle($hgui,"",$fps&" FPS")
$fps=0
endfunc
Func _Exit()
Exit
EndFunc
func _createbytecode()
[/autoit] [autoit][/autoit] [autoit]FasmReset($Fasm)
[/autoit] [autoit][/autoit] [autoit]FasmAdd($Fasm, "use32")
FasmAdd($Fasm, "org " & FasmGetBasePtr($Fasm))
FasmAdd($Fasm, "mov eax,[esp+4]") ;breite
FasmAdd($Fasm, "mov [breite],eax") ;
FasmAdd($Fasm, "mov eax,[esp+8]") ;hoehe
FasmAdd($Fasm, "mov [hoehe],eax") ;
FasmAdd($Fasm, "mov eax,[esp+12]") ;A1
FasmAdd($Fasm, "mov [va1],eax") ;
FasmAdd($Fasm, "mov edi,[esp+16]") ;Ptr auf bitmapdaten
FasmAdd($Fasm, "FINIT") ;copro init 10
;die Tabelle mit Werten füllen
FasmAdd($Fasm, "mov ecx,1000") ;tabellenlimit
FasmAdd($Fasm, "mov ebx,-1") ;zähler tabellenindex
;atantabelle[ebx]=ATAN(ebx/100)
FasmAdd($Fasm, "_atanschleife:") ;
FasmAdd($Fasm, "inc ebx") ;index eins höher
FasmAdd($Fasm, "mov dword [atanindex],ebx ") ;index in speicher
FasmAdd($Fasm, "fild dword [atanindex]") ;st0=index
FasmAdd($Fasm, "fidiv dword[hundert]") ;st0=index/100
FasmAdd($Fasm, "fld1") ;st0=1 st1=index/100
FasmAdd($Fasm, "fpatan") ; ;st0=atan(st1/st0)
FasmAdd($Fasm, "fstp dword[atantabelle+ebx*4]") ;atan im atantabelle[index*4] speichern
FasmAdd($Fasm, "cmp ebx, ecx") ;ist limit erreicht?
FasmAdd($Fasm, "jne _atanschleife") ;wenn limit noch nicht erreicht, dann nächsten index
;lookup-tabelle gefüllt
FasmAdd($Fasm, "mov dword[vi],0") ;schleifenzähler
FasmAdd($Fasm, "mov dword[vj],0") ;
;stack mit konstanten laden, diese bleiben während des gesamten durchlaufs im stack!
FasmAdd($Fasm, "fld1") ;st0=1
FasmAdd($Fasm, "fidiv [hoehe] ") ;st0=1/h
FasmAdd($Fasm, "fld [minuseinhalb]") ;st0=-0.5
FasmAdd($Fasm, "fld [zwonulldrei]") ;st0=203.xx st1=-0.5
FasmAdd($Fasm, "fld [nulldrei]") ;st0=0.39 st1=203.xx st2=-0.5 st3=1/h
;leider hat die inverse breite keinen platz mehr auf dem stack gefunden und muss in speicher gelagert werden
FasmAdd($Fasm, "fld1") ;st0=1 st1=breite
FasmAdd($Fasm, "fidiv [breite]") ;st0=1/b
FasmAdd($Fasm, "fstp [invbreite]") ;st0=0.39 st1=203.xx st2=-0.5 st3=1/h 21
;schleifen
FasmAdd($Fasm, "mov edx,[hoehe]") ;schleifenzähle höhe
FasmAdd($Fasm, "i_schleife:") ; for i=0 to h
FasmAdd($Fasm, "mov ecx,[breite]") ; schleifenzähler breite
FasmAdd($Fasm, "j_schleife:") ; for j=0 to w
;~ ;$dx=($j-$HW)/$W;
FasmAdd($Fasm, "fild dword[vj]") ;st0=j st1=0.39 st2=203.xx st3=-0.5 st4=1/h
FasmAdd($Fasm, "fmul [invbreite] ") ;st(0)=j/w
FasmAdd($Fasm, "fadd st0,st3") ;st(0=j/w-0.5 st1=0.39 st2=203.xx st3=-0.5 st4=1/h
;$dy=($i-$HH)/$H
FasmAdd($Fasm, "fild [vi]") ;st0=i st1=dx st2=0.39 st3=203.xx st4=-0.5 st5=1/h
FasmAdd($Fasm, "fmul st0,st5") ;st(0)=i/h
FasmAdd($Fasm, "fadd st0,st4") ;st(0)=i/h-0.5=dy st1=dx st2=0.39 st3=203.xx st4=-0.5 st5=1/h
;$sqrt=sqrt(dx^2+dy^2)
FasmAdd($Fasm, "fld st1") ;dx 45
FasmAdd($Fasm, "fmul st0,st0") ;dx^2
FasmAdd($Fasm, "fld st1") ;dy
FasmAdd($Fasm, "fmul st0,st0") ;dy^2
FasmAdd($Fasm, "faddp st1,st0") ;dx^2+dy^2
FasmAdd($Fasm, "fsqrt") ;st0=sqrt st1=dy st2=dx
;dy/(dx+sqrt)
FasmAdd($Fasm, "fld st0") ;st0=sqrt st1=sqrt st2=dy st3=dx
FasmAdd($Fasm, "fadd st0,st3") ;st0=sqrt+dx st1=sqrt st2=dy st3=dx
FasmAdd($Fasm, "fdivr st0,st2") ;st0=y/(sqrt+dx) st1=sqrt st2=dy st3=dx
;ab hier wird FPATAN() durch einen Zugriff auf die Tabelle ersetzt
;an atantabelle[index] steht der atan(index/100), also alle arcustangens von 0 bis 10
;index>10
FasmAdd($Fasm, "fcom dword[zehn]") ;vgl st0 mit zehn (kein platz mehr auf dem stack....)
FasmAdd($Fasm, "fstsw ax") ;statuswort copro in ax
FasmAdd($Fasm, "sahf") ;AH ---> prozessorflags
FasmAdd($Fasm, "jb kleinerzehn") ;wenn größer/gleich +10, dann eax=atantabelle[1000]
FasmAdd($Fasm, "fstp st0") ;runter vom stack
FasmAdd($Fasm, "fld [atantabelle+4000]") ;wenn größer/gleich +10, dann 1.4711
FasmAdd($Fasm, "jmp weiter") ;atan berechnet^^
;index<-10
FasmAdd($Fasm, "kleinerzehn:")
FasmAdd($Fasm, "fcom dword[minuszehn]") ;vgl st0 mit -zehn (kein platz mehr auf dem stack....)
FasmAdd($Fasm, "fstsw ax") ;statuswort copro in ax
FasmAdd($Fasm, "sahf") ;AH ---> prozessorflags
FasmAdd($Fasm, "ja groessernull") ;wenn >-10 dann groessernull
FasmAdd($Fasm, "fstp st0") ;runter vom stack
FasmAdd($Fasm, "fld [atantabelle+4000]") ;wenn größer/gleich +10, dann 1.4711
FasmAdd($Fasm, "fchs") ;vorzeichen auf minus
FasmAdd($Fasm, "jae weiter")
;index>0
FasmAdd($Fasm, "groessernull:")
FasmAdd($Fasm, "fcom dword[null]") ;vgl st0 mit null (kein platz mehr auf dem stack....)
FasmAdd($Fasm, "fstsw ax") ;statuswort copro in ax
FasmAdd($Fasm, "sahf") ;AH ---> prozessorflags
FasmAdd($Fasm, "jbe kleinernull") ;wenn kleiner null, dann kleinernull
FasmAdd($Fasm, "fimul dword[hundert]") ;st0=100*y/(sqrt+dx) st1=sqrt st2=dy st3=dx
FasmAdd($Fasm, "fistp [atanindex]") ;runter vom stack
FasmAdd($Fasm, "fwait") ;
FasmAdd($Fasm, "mov eax,[atanindex]") ;
FasmAdd($Fasm, "fld [atantabelle+4*eax]") ;wenn größer/gleich 0, dann atantabelle[index] holen
FasmAdd($Fasm, "jae weiter")
;index<0
FasmAdd($Fasm, "kleinernull:") ;wenn kleiner null
FasmAdd($Fasm, "fimul dword[hundert]") ;st0=100*y/(sqrt+dx) st1=sqrt st2=dy st3=dx
FasmAdd($Fasm, "fchs") ;vorzeichen auf plus
FasmAdd($Fasm, "fistp [atanindex]") ;runter vom stack
FasmAdd($Fasm, "fwait") ;
FasmAdd($Fasm, "mov eax,[atanindex]") ;
FasmAdd($Fasm, "fld [atantabelle+4*eax]") ;atan(index/100)
FasmAdd($Fasm, "fchs") ;vorzeichen auf minus
;st0=atan2 , das wars, ca. 50 Zeilen mehr Code, um EINEN Befehl zu ersetzen
FasmAdd($Fasm, "weiter: ") ;
;$tu=int($5div2pi*[ATantabelle+eax]))
FasmAdd($Fasm, "fmul st0,st5") ;st0=atan2*203 st1=sqrt st2=dy st3=dx
FasmAdd($Fasm, "fistp [vtu]") ; st0=sqrt st1=dy st2=dx st3=0.39 st4=203.xx st5=-0.5 st6=1/h
;$tv=($nulldrei/sqrt($dx*$dx+$dy*$dy))+$a1
FasmAdd($Fasm, "fdivr st0,st3 ");st0=0.3/sqrt st1=dy st2=dx st3=0.39 st4=203.xx st5=-0.5 st6=1/h
FasmAdd($Fasm, "fadd [va1]") ;st0=0.3/sqrt+a1
FasmAdd($Fasm, "fimul [v256]") ;st0=(0.3/sqrt+a1)*256
FasmAdd($Fasm, "fistp [vtv]") ;st0=dy st1=dx st3=0.39 st4=203.xx st5=-0.5 st6=1/h
FasmAdd($Fasm, "fstp st0") ;st0=dx st1=0.39 st2=203.xx st3=-0.5 st4=1/h
FasmAdd($Fasm, "fstp st0") ;st0=0.39 st1=203.xx st2=-0.5 st3=1/h
;stack ist in dem zustand, wie er am anfang der schleife war
[/autoit] [autoit][/autoit] [autoit];XOR
FasmAdd($Fasm, "mov eax,[vtu]") ;
FasmAdd($Fasm, "xor eax,[vtv]") ;
FasmAdd($Fasm, "and eax,0xFF") ;farbe von RR, GG und BB
;pixelfarbe (grauton) erstellen
FasmAdd($Fasm, "mov ebx,0xFF") ;alpha AA
FasmAdd($Fasm, "shl ebx,8") ;AA00
FasmAdd($Fasm, "or ebx,eax") ;AABB
FasmAdd($Fasm, "shl ebx,8") ;AABB00
FasmAdd($Fasm, "or ebx,eax") ;AABBGG
FasmAdd($Fasm, "shl ebx,8") ;AABBGG00
FasmAdd($Fasm, "or eax,ebx") ;AABBGGRR
FasmAdd($Fasm, "stosd") ;mov [edi],eax pixel in die bitmap schreiben
FasmAdd($Fasm, "dec ecx" ) ;schleifenzähler breite
FasmAdd($Fasm, "mov [vj],ecx" ) ;schleifenzähler breite
FasmAdd($Fasm, "jnz j_schleife") ;so lange bis 0
FasmAdd($Fasm, "dec edx") ;schleifenzähler hoehe
FasmAdd($Fasm, "mov [vi],edx" ) ;schleifenzähler breite
FasmAdd($Fasm, "jnz i_schleife") ;so lange bis 0
FasmAdd($Fasm, "ret 16");Programmende
[/autoit] [autoit][/autoit] [autoit];variablen,
[/autoit] [autoit][/autoit] [autoit]FasmAdd($Fasm, "nulldrei dd 0.390625") ;100/256
FasmAdd($Fasm, "zwonulldrei dd 203.718330632686")
FasmAdd($Fasm, "minuseinhalb dd -0.5")
FasmAdd($Fasm, "v256 dd 256")
FasmAdd($Fasm, "hoehe dd 0")
FasmAdd($Fasm, "breite dd 0")
FasmAdd($Fasm, "invbreite dd 0.0")
FasmAdd($Fasm, "va1 dd 0.0")
FasmAdd($Fasm, "vtu dd 0")
FasmAdd($Fasm, "vtv dd 0")
FasmAdd($Fasm, "vi dd 0")
FasmAdd($Fasm, "vj dd 0")
FasmAdd($Fasm, "hundert dd 100")
FasmAdd($Fasm, "null dd 0.0")
FasmAdd($Fasm, "zehn dd 10.0")
FasmAdd($Fasm, "minuszehn dd -10.0")
FasmAdd($Fasm, "atanindex dd 0")
FasmAdd($Fasm, "atantabelle dd 1000 dup 0") ;array mit 1000 werten für atantabelle[atanindex]=atanvalue erstellen
$Binary = FasmGetBinary($Fasm) ;syntaxerror im Assembler abfangen abfangen
;~ If @Extended Then ;syntax-error aufgetreten
;~ $Error = FasmGetLastError()
;~ ConsoleWrite("Error Code:" & $Error[0] & @CRLF & "Error Message:" & $Error[1] & @CRLF & "Error Line:" & $Error[2] & @CRLF)
;~ Else ;syntax ok
ConsoleWrite(String(FasmGetBinary($Fasm)) & @CRLF)
filedelete("test.bin") ;assembly für externen debugger
filewrite("test.bin",binarytostring(String(FasmGetBinary($Fasm))))
endfunc
[/autoit] [autoit][/autoit] [autoit][/autoit] [autoit][/autoit] [autoit][/autoit] [autoit]Func _CreateNewBmp32($iwidth, $iheight, ByRef $ptr, ByRef $hbmp) ;erstellt leere 32-bit-Bitmap; Rückgabe DC und ptr und handle auf die Bitmapdaten
;by Andy
Local $hcdc = _WinAPI_CreateCompatibleDC(0) ;Desktop-Kompatiblen DeviceContext erstellen lassen
Local $tBMI = DllStructCreate($tagBITMAPINFO) ;Struktur der Bitmapinfo erstellen und Daten eintragen
DllStructSetData($tBMI, "Size", DllStructGetSize($tBMI) - 4);Structgröße abzüglich der Daten für die Palette
DllStructSetData($tBMI, "Width", $iwidth)
DllStructSetData($tBMI, "Height", -$iheight) ;minus =standard = bottomup
DllStructSetData($tBMI, "Planes", 1)
DllStructSetData($tBMI, "BitCount", 32) ;32 Bit = 4 Bytes => AABBGGRR
Local $adib = DllCall('gdi32.dll', 'ptr', 'CreateDIBSection', 'hwnd', 0, 'ptr', DllStructGetPtr($tBMI), 'uint', $DIB_RGB_COLORS, 'ptr*', 0, 'ptr', 0, 'uint', 0)
$hbmp = $adib[0] ;hbitmap handle auf die Bitmap, auch per GDI+ zu verwenden
$ptr = $adib[4] ;pointer auf den Anfang der Bitmapdaten, vom Assembler verwendet
;_arraydisplay($adib)
_WinAPI_SelectObject($hcdc, $hbmp) ;objekt hbitmap in DC
Return $hcdc ;DC der Bitmap zurückgeben
EndFunc ;==>_CreateNewBmp32
/EDIT/ Anbei das äquivalente AutoIt-Script. Was einige vielleicht wundern wird, wieso profitiert AutoIt in keinster Weise von der Optimierung?
AutoIt ist (Dank an die Entwickler) schon ziemlich nah am Optimum! Der Verwaltungsaufwand für die Interpretation des von uns geschriebenen Scriptes ist so hoch, daß einzelne Optimierungen, die bei einem Compiler sofort wirksam werden, von der Anzahl der dadurch mehr ausgeführten Befehle aufgefressen werden.
Gerade bei Algorithmen, welche extrem auf einen häufig genutzten "inner Loop" aufbauen, lohnt sich daher die Suche nach Alternativen! Dictionarys oder Listen statt Arrays können ab und zu etwas Schub bringen, das wichtigste ist aber, CODE einzusparen! Jeder Befehl, den AutoIt NICHT interpretieren muss, beschleunigt unser Programm...
;Idea taken from http://js1k.com/demo/462
;Ported to AutoIt by UEZ Build 2010-08-20
#AutoIt3Wrapper_UseUpx=n
#AutoIt3Wrapper_Run_Obfuscator=y
#Obfuscator_Parameters=/sf /sv /om /cs=0 /cn=0
#AutoIt3Wrapper_Run_After=del /f /q "Star Burst_Obfuscated.au3"
#AutoIt3Wrapper_Run_After=upx.exe --ultra-brute "%out%"
;~ #AutoIt3Wrapper_Run_After=upx.exe --best "%out%"
#include <GDIPlus.au3>
#include <GUIConstantsEx.au3>
;Opt("MustDeclareVars", 1)
Opt("GUIOnEventMode", 1)
Local $hGUI, $hGraphics, $hBackbuffer, $hBitmap
Local $H = 332, $W = 332
; Initialize GDI+
_GDIPlus_Startup()
$hGUI = GUICreate("GDI+ Test", $W, $H)
GUISetState()
$hGraphics = _GDIPlus_GraphicsCreateFromHWND($hGUI)
$hBitmap = _GDIPlus_BitmapCreateFromGraphics($W, $H, $hGraphics)
$hBackbuffer = _GDIPlus_ImageGetGraphicsContext($hBitmap)
; Using antialiasing
;~ _GDIPlus_GraphicsSetSmoothingMode($hBackbuffer, 0)
; Create a Brush object
Local $hBrush = _GDIPlus_BrushCreateSolid()
GUISetOnEvent($GUI_EVENT_CLOSE, "_Exit")
[/autoit] [autoit][/autoit] [autoit][/autoit] [autoit]Dim $atan_array[1000]
For $i = 0 To 999
$atan_array[$i] = ATan($i / 100)
Next
AdlibRegister("_fps", 1000)
[/autoit] [autoit][/autoit] [autoit][/autoit] [autoit]Global $pi = ACos(-1), $pi2 = 2 * $pi, $pi05 = ACos(-1) * 0.5, $fps
Local $HW = $H * 0.5, $HH = $W * 0.5
Local $A0 = 0, $A1 = 0, $A2 = 0, $A3 = 0
Local $ox = 0, $oy = 0, $0z = 0
Local $tu = 0, $tv = 0
Local $speed = 2
Local $i, $j, $x, $y, $o
Local $cc, $ss, $z, $col
Local $dx, $dy, $dz, $rd, $A, $B, $C, $R, $t1, $tu, $tv, $q, $g, $l
Local $d[$W + 1]
$viernullsechs = 203.718330632686 * 2
$nulldrei = 0.390625
;$a1=0.07
While 1;Sleep(10)
_GDIPlus_GraphicsClear($hBackbuffer, 0xFF000000)
For $i = 0 To $H Step $speed
For $j = 0 To $W Step $speed
$dx = ($j / $W) - 0.5;
$dy = ($i / $H) - 0.5;
$sqrt = Sqrt($dx * $dx + $dy * $dy)
$tu = Int($viernullsechs * _atan($dy / ($dx + $sqrt)))
$tv = ($nulldrei / $sqrt) + $A1
$tv = Int($tv * 256)
$g = Hex(BitAND(BitXOR($tu, $tv), 0xFF), 2)
$col = "0xFF" & $g & $g & $g
_GDIPlus_BrushSetSolidColor($hBrush, $col)
_GDIPlus_GraphicsFillRect($hBackbuffer, $j, $i, $speed, $speed, $hBrush)
Next
Next
$A1 += 0.07
;exit
_GDIPlus_GraphicsDrawImageRect($hGraphics, $hBitmap, 0, 0, $W, $H)
$fps += 1
WEnd
Func _FPS()
WinSetTitle($hGUI, "", $fps)
$fps = 0
EndFunc ;==>_FPS
Func Rotate($t)
$cc = Cos($t)
$ss = Sin($t)
$z = $x * $cc - $y * $ss
$y = $x * $ss + $y * $cc
$x = $z
EndFunc ;==>Rotate
Func _atan($R)
If $R < 0 Then
If $R < -9.9 Then Return -1.4711
Return -$atan_array[Int(Abs($R * 100))]
Else
If $R > 9.9 Then Return 1.4711
Return $atan_array[Int(Abs($R * 100))]
EndIf
EndFunc ;==>_atan
Func atan2($y, $x)
Local $A = (2 * ATan($y / ($x + Sqrt($x * $x + $y * $y))))
ConsoleWrite($y & " " & $x & " " & $A & @CRLF)
Return $A
EndFunc ;==>atan2
Func ATan2_UEZ($y, $x)
Switch $x
Case ($x > 0)
Return ATan($y / $x)
Case ($x < 0 And $y >= 0)
Return ATan($y / $x + $pi)
Case ($x < 0 And $y < 0)
Return ATan($y / $x - $pi)
Case ($x = 0 And $y > 0)
Return $pi05
Case ($x = 0 And $y < 0)
Return -$pi05
Case ($x = 0 And $y = 0)
Return 0
EndSwitch
EndFunc ;==>ATan2_UEZ
Func _Exit()
; Clean up
_GDIPlus_BrushDispose($hBrush)
_GDIPlus_BitmapDispose($hBitmap)
_GDIPlus_GraphicsDispose($hBackbuffer)
_GDIPlus_GraphicsDispose($hGraphics)
; Uninitialize GDI+
_GDIPlus_Shutdown()
Exit
EndFunc ;==>_Exit
hast du das Script aus meinem Post ausprobiert? Bei mir läuft das einwandfrei, erst verschlüsseln, dann entschlüsseln
Dein Programm funktioniert einwandfrei!
;kann man in einer Zeile mit lea esi,[esp+4] machen
FasmAdd($Fasm, "mov eax,[esp+4]");Parameter abspeichern
FasmAdd($Fasm, "mov esi,[eax]");Hier wird der String später herausgeholt (Source) (str* to str)
;hier genauso
FasmAdd($Fasm, "mov eax,[esp+8]");
FasmAdd($Fasm, "mov eax,[eax]");str* zu str, Passwort in eax speichern
FasmAdd($Fasm, "mov edi,nstr");nstr=Platz für neuen String, Pointer nach edi (Destination)
FasmAdd($Fasm, "mov ecx,0");Passwortzähler, um per Zähler jeden einzelnen Buchstaben zu benutzen
FasmAdd($Fasm, "schleife:");Schleifenlabel
;wenn du words benutzt, dann nur bei unicode! bei ansi ist ein byte = ein Buchstabe!
;also beim dllcall wstr für unicode einsetzen
FasmAdd($Fasm, "mov bx,word[esi]");aktuellen Stringbuchstaben in bx speichern
FasmAdd($Fasm, "xor bx,word[eax+ecx]");und mit aktuellem Buchstaben des Passworts verschlüsseln
FasmAdd($Fasm, "mov word[esi],bx");den Buchstaben wieder zurückschreiben
FasmAdd($Fasm, "add ecx,2");Passwortzähler um ein Word erhöhen
FasmAdd($Fasm, "cmp word[eax+ecx],0");Prüfen ob das Ende des Passworts am neuen Ort ist
FasmAdd($Fasm, "je znull");und wenn es so ist, dann den Zähler bei znull zurücksetzen
FasmAdd($Fasm, "back:");Label um von der Funktion zurückzukehren
FasmAdd($Fasm, "movsw");Einen Buchstaben von Surce nach Destination verschieben
FasmAdd($Fasm, "cmp word[esi],0");Prüfen ob es der letzte Buchstabe war
FasmAdd($Fasm, "jne schleife");wenn nicht, dann wiederhole Schleife
FasmAdd($Fasm, "jmp ende");sons springe zum Ende
FasmAdd($Fasm, "znull:");Label für Funktion
FasmAdd($Fasm, "mov ecx,0");Zähler zurücksetzen
FasmAdd($Fasm, "jmp back");zurückspringen
FasmAdd($Fasm, "ende:");Label fürs Ende
FasmAdd($Fasm, "mov eax,nstr");neuen String zurückgeben
FasmAdd($Fasm, "ret 8");Beenden
FasmAdd($Fasm, "nstr dw 100 dup(0)");Platz für neuen String, mit nstr dw 0 reservierst du nur ein! dword...
;
; FasmCompile($Fasm)
If @Error Then
;~ Local $Error = FasmGetLastError()
;~ ConsoleWrite("Error Code: " & $Error[$FASMERRINDEX_CODE] & @CRLF)
;~ ConsoleWrite("Error Message: " & $Error[$FASMERRINDEX_MESSAGE] & @CRLF)
;~ ConsoleWrite("Error LineNumber: " & $Error[$FASMERRINDEX_LINENUMBER] & @CRLF)
;~ ConsoleWrite("Error Line: " & $Error[$FASMERRINDEX_LINE] & @CRLF)
Else
ConsoleWrite(String(FasmGetBinary($Fasm)) & @CRLF)
EndIf
Local $timer=TimerInit()
Local $ret = MemoryFuncCall("wstr", FasmGetFuncPtr($Fasm), "wstr*", "Hallo", "wstr*", "PW")
Local $diff=TimerDiff($timer)
MsgBox(0,$diff,$ret[0])
ConsoleWrite($ret[0]&@CRLF)
$text=$ret[0]
; Local $timer=TimerInit()
Local $ret = MemoryFuncCall("wstr", FasmGetFuncPtr($Fasm), "wstr*",$text , "wstr*", "PW")
Local $diff=TimerDiff($timer)
MsgBox(0,$diff,$ret[0])
ConsoleWrite($ret[0]&@CRLF)
Da du aber ein WORD verschlüsselst, musst du den Buchstaben bzw String auch als Unicodezeichen an den assemblercode übergeben!
das war alles....wstr statt str im dllcall
oder dann imm Assemblercode byteweise, wenn du nur Ansistrings hast str=ansi ; 1 char=1 byte
Das was mich am meisten wundert ist die Größe der Datei mit 4294967295, das ist nämlich 0xFFFFFFFF, sehr ungewöhnlich, da der Server im Zweifelsfall als Größe 0 zurückgibt.
Entweder benutzt du eine nicht aktuelle FTPex.AU3, oder sonst ist irgendetwas faul.
Funktioniert das Beispielscript aus der Hilfe zu _FTP_FileGetSize?
Dort wird die Dateigröße des (zuerst gefundenen Verzeichnisses "Contrib" ) auch mit 0 angegeben, aber die Dateigröße von der Datei "Public-Key" wird richtigerweise mit 2201 zurückgegeben.
Ich gehe einfach mal davon aus, daß du die bei UNIX-Servern nötige Groß/Kleinschreibung beachtest.
Das Beispiel aus der Hilfe:
#include <FTPEx.au3>
#include <Array.au3>
$server = 'ftp.csx.cam.ac.uk'
$username = ''
$pass = ''
$Open = _FTP_Open('MyFTP Control')
$Conn = _FTP_Connect($Open, $server, $username, $pass)
$dirset=_FTP_DirSetCurrent($Conn, "/pub/software/programming/pcre/")
$FileSize = _FTP_FileGetSize($Conn, "Public-Key")
MsgBox(262144,'Debug line ~' & @ScriptLineNumber,'Selection:' & @lf & '$FileSize' & @lf & @lf & 'Return:' & @lf & $FileSize) ;### Debug MSGBOX
Local $h_Handle
$aFile = _FTP_FindFileFirst($Conn, "/pub/software/programming/pcre/", $h_Handle)
_arraydisplay($afile)
ConsoleWrite('$Filename = ' & $aFile[10] & ' attribute = ' & $aFile[1] & ' -> Error code: ' & @error & ' extended: ' & @extended & @crlf)
$dirset=_FTP_DirSetCurrent($Conn, "/pub/software/programming/pcre/")
ConsoleWrite('$dirset = ' & $dirset & ' -> Error code: ' & @error & ' extended: ' & @extended & @crlf)
$FileSize = _FTP_FileGetSize($Conn, $aFile[10])
ConsoleWrite('$Filename = ' & $aFile[10] & ' size = ' & $FileSize & ' -> Error code: ' & @error & ' extended: ' & @extended & @crlf)
Local $Err, $Message
$FileSize = _FTP_GetLastResponseInfo($Err, $Message) ; error = Contrib: Not a regular file
ConsoleWrite('$Message = ' & $Message & ' err = ' & $Err & ' -> Error code: ' & @error & ' extended: ' & @extended & @crlf)
$aFile = _FTP_FindFileNext($h_Handle)
ConsoleWrite('$FilenameNext1 = ' & $aFile[10] & ' attribute = ' & $aFile[1] & ' -> Error code: ' & @error & ' extended: ' & @extended & @crlf)
$FileSize = _FTP_FileGetSize($Conn, $aFile[10])
ConsoleWrite('$FilenameNext1 = ' & $aFile[10] & ' size = ' & $FileSize & ' -> Error code: ' & @error & ' extended: ' & @extended & @crlf)
$FileSize = _FTP_GetLastResponseInfo($Err, $Message) ; no error
ConsoleWrite('$Message = ' & $Message & ' err = ' & $Err & ' -> Error code: ' & @error & ' extended: ' & @extended & @crlf)
$FindClose = _FTP_FindFileClose($h_Handle)
[/autoit] [autoit][/autoit] [autoit]$Ftpc = _FTP_Close($Open)
[/autoit]im Durchschnitt eben eher Eltern aus einer bestimmten Schicht ihre Kinder beispielsweise "Kevin" nennen
oder Mandy oder Peggy, aber "Schantalle" ist auch nicht schlecht 
Wir leben hier auf dem flachen Land, bei Chantal stelle ich mir eine zierliche, dunkelhaarige, aristokratische Französin vor, aber kein 10-jähriges strohblondes Mädchen, welches 60 Kilo wiegt und nicht mehr aus den Augen gucken kann. Und die dazu passende Mutter kreischt durchs halbe Ort: "SCHANTAAAAALLLLEEEEE, komm heim, du musst Opa noch die Fussnägel schneiden!"
Manchmal wird einem sehr schnell klar, warum manche Männer am Tag 1-2 Flaschen Schnaps brauchen...
@Pee, das wird daran liegen, daß "INIs" (hier im Forum zumindest) recht häufig für Sachen missbraucht werden, für die sie gar nicht vorgesehen sind. (Wozu gibt es sonst eine UDF, welche die 32K-Beschränkung aufhebt?)
Es könnte natürlich an dem einfachen Zugriff auf die INI-Funktionen liegen^^
Dass es meist viel einfachere (und schnellere) Lösungen gibt, Daten in Textdateien zu ändern bzw darauf zuzugreifen, wird dabei oft unter den Tisch gekehrt.
Wobei im vorliegenden Fall ja nicht die Reihenfolge der Namen innerhalb der INI-Datei selbst sortiert werden soll, sondern nachher im Programm. Dann kann man auch die INI mit einem Texteditor bearbeiten, irgendetwas dazuschreiben und/oder löschen und das Programm funktioniert trotzdem wie gewollt.
Ein Arschlochkind ist ein Arschlochkind, egal wie es heisst! Dementsprechend werden auch die Noten ausfallen.
Und die Tatsache, daß Lehrer "Sympathienoten" vergeben, ist so alt wie die Schule selbst. Das belegt auch der Satz aus dem Zeitungsbericht
Das führt Kaiser darauf zurück, dass die Notengebung bei offenen gestellten Fragen selten objektiv ist.
.
Aha, es geht also nicht um Mathe, Physik, Chemie, Rechtschreibung oder Vokabeltests....sondern um die sog. "Sabbel- oder Schwall-Aufgaben!" wie z.B. " Fasse den Inhalt des alten Testaments und die Bedeutung für die Menschheit in eigenen Worten auf einer Seite zusammen!"
Naja, wenn der weitere Lebensweg davon abhängt, ob einem ein Lehrer da eine 3 oder eine 4 gibt, dann sollte man sich nicht fragen wie man heisst, sondern ob man in den anderen Fächern (die großteils objektiv bewertet werden (müssen)), wie z.B. Mathe, nicht einfach eine 1 oder eine 2 vorlegt und so gemütlich die "schlechtere" Note im Gesabbel ausgleicht!
ob ein Sound ungefähr gleich ist wie ein vorgegebener
Was ist ungefähr?
Und um welche Sounds geht es? Sinus-oder Rechteckwellen, Musik, Sprache, Rauschen....?
In welchem Format liegen die "Sounds" vor?
Quatsch kann doch die lib nehmen .
Richtig, und Ausgabe in Fensterchen mit allem pipapo^^
Na was willst du denn ausgeben?
Zzt hast du Glück, da der INHALT von an der Adresse von EAX irgendetwas ist, ziemlich wahrscheinlich sogar dort "nichts" im Speicher steht...
Ausserdem werden Strings mit $ abgeschlossen!
unser_text db "Hallo", "$"so wie in deinem Post#20 ist es richtig^^
Um INTEGER in einen STRING umzuwandeln gibts reichlich Funktionen, eine hab ich mal im Primzahlenprogramm verwendet...
Wenn du aber sowieso FASM benutzt, dann kannst du auch die Bibliotheken einbinden, das ist das einfachste!
Dim $Fasm = FasmInit()
FasmReset($Fasm)
FasmAdd($Fasm, "use32")
FasmAdd($Fasm, "org " & FasmGetBasePtr($Fasm))
FasmAdd($Fasm, " mov ebx,[esp+4] ");integer
FasmAdd($Fasm, " mov edi,puffer ");pointer auf die struct
;aus einem integer einen string machen
FasmAdd($Fasm, " push ebx ");alle benötigten Register sichern
FasmAdd($Fasm, " push ecx ");alle benötigten Register sichern
FasmAdd($Fasm, " mov eax, ebx ");Zahl laden
FasmAdd($Fasm, " mov ebx, 10 "); Divisor
FasmAdd($Fasm, " xor ecx, ecx ");ECX=0 (Anzahl der Ziffern)
FasmAdd($Fasm, "Schleife_1: ")
FasmAdd($Fasm, "xor edx, edx ")
FasmAdd($Fasm, "div ebx "); EDX:EAX / EBX = EAX Rest EDX
FasmAdd($Fasm, "push dx "); LIFO
FasmAdd($Fasm, "add cl,1 "); ADD soll schneller sein als INC
FasmAdd($Fasm, "or eax, eax "); AX = 0?
FasmAdd($Fasm, "jnz Schleife_1 "); nein: nochmal
FasmAdd($Fasm, "Schleife_2:")
FasmAdd($Fasm, "pop ax "); gepushte Ziffern zurückholen
FasmAdd($Fasm, "or al, 00110000b "); Umwandlung in ASCII
FasmAdd($Fasm, "stosb "); Nur AL nach [EDI] (EDI ist ein Zeiger auf den String)
FasmAdd($Fasm, "loop Schleife_2 "); bis keine Ziffern mehr da sind
FasmAdd($Fasm, "mov byte [edi],0Dh ");CR CarriageReturn, man könnte auch ein Komma (ascii=2C) einsetzen
FasmAdd($Fasm, "add edi,1 ");ein Byte weiter
FasmAdd($Fasm, " pop ecx ");Register wiederherstellen
FasmAdd($Fasm, " pop ebx ");Register wiederherstellen
;ende integer2string
; FasmAdd($Fasm, "mov eax,0")
FasmAdd($Fasm, "mov eax,puffer") ;rückgabe auf puffer
FasmAdd($Fasm, "ret 4") ;Funktionsende
FasmAdd($Fasm, "puffer db 1 dup(10)");integer hat maximal 10 dezimalstellen!
; FasmAdd($Fasm, "Nachricht db 'Teststring!$'")
$integer=12345678
[/autoit] [autoit][/autoit] [autoit]$Ret = MemoryFuncCall("str", FasmGetFuncPtr($Fasm), "int", $integer)
[/autoit] [autoit][/autoit] [autoit]_arraydisplay($ret)
FasmExit($Fasm)
exit
wenn du diese Funktion mit dem Int21h verwenden willst, musst du statt des CR ein $ an den String anschliessen!
probier das mal aus,
Func getDCfromfile($bmpfile, ByRef $ptr) ;ptr to bitmapdata, it is possible to manipulate one pixel if needed
$hbitmap = _GDIPlus_BitmapCreateFromFile($bmpfile)
$hbmp = _GDIPlus_BitmapCreateHBITMAPFromBitmap($hbitmap)
$iwidth = _GDIPlus_ImageGetWidth($hbitmap)
$iheight = _GDIPlus_ImageGetHeight($hbitmap)
$tBMI = DllStructCreate($tagBITMAPINFO)
DllStructSetData($tBMI, "Size", DllStructGetSize($tBMI) - 4)
DllStructSetData($tBMI, "Width", $iwidth)
DllStructSetData($tBMI, "Height", -$iheight)
DllStructSetData($tBMI, "Planes", 1)
DllStructSetData($tBMI, "BitCount", $iBitCount)
$hdc = _WinAPI_GetDC(0)
$hcdc = _WinAPI_CreateCompatibleDC($hdc)
$adib = DllCall('gdi32.dll', 'ptr', 'CreateDIBSection', 'ptr', 0, 'ptr', DllStructGetPtr($tBMI), 'uint', 1, 'ptr*', 0, 'ptr', 0, 'uint', 0)
; select object
_WinAPI_SelectObject($hcdc, $adib[0])
; copy the content of the bitmap into the buffer ...
_WinAPI_GetDIBits($hdc, $hbmp, 0, $iheight, $adib[4], DllStructGetPtr($tBMI), 1)
; create the a dllstruct with the pointer $aDIB[4]
$stride = 3 * $iwidth + Mod($iwidth, 4) ;number of bytes in one line (filled with some bytes, because it must be a multiple of four!)
$tBits = DllStructCreate('byte[' & $stride * $iheight & ']', $adib[4])
$ptr = DllStructGetPtr($tBits)
_GDIPlus_BitmapDispose($hbitmap)
_WinAPI_DeleteObject($adib[0])
Return $hcdc ;MemoryDC of bitmap
EndFunc ;==>getDCfromfile
damit hast du den dc der grafik und natürlich auch den pointer
wenn du schon ein img z.b. in einer GUI gezeichnet hast, dann kannst du den DC der GUI nehmen und in deinen Puffer blitten, dort dann ändern und wieder zurückblitten