Neue Antwort erstellen

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.

Informationen
Frage Bitte beantworten Sie die untenstehende Frage bzw. lösen Sie die untenstehende Aufgabe.
Nachricht
Internet-Adressen werden automatisch erkannt und umgewandelt.
Smiley-Code wird in Ihrer Nachricht automatisch als Smiley-Grafik dargestellt.
Sie können BBCodes zur Formatierung Ihrer Nachricht nutzen.

Vorherige Beiträge 80

  • Ach ja:

    Quellcode

    1. ds "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0A\x0B\x0C\x0D\x0E\x0F"
    kann man auch einfacher schreiben:

    Quellcode

    1. dh "000102030405060708090A0B0C0D0E0F"
    Gruß
    Roland
  • Ok, bei mir klappt es jetzt. Das war nicht ganz einfach. Natürlich darf das Anführungszeichen im String nur als "\q" oder "\x22" vorkommen. Komma und Semikolon machen auch keine Probleme mehr.

    Ich werde demnächst also auch noch diesen Bugfix hochladen. Außerdem komme ich mit der Dokumentation ein wenig voran. Es wird zunächst eine PDF-Datei mit all den Neuerungen geben. Diese wird dann als Grundlage für das Erweitern der Hilfe dienen.

    Gruß
    Roland
  • Frage: Ich habe Probleme, dem Inline-ASM Interpreter die String charakters "=34 ,=44 und ;=59
    beizubringen. Der ds Befehl bricht mit Fehler ab, auch wenn man statt " \x22 verwenden will. Maskieren mit \ klappt auch nicht. Betrifft das nur den X4-Beta Interpreter?

    P.S.: Den Fehler ab Zeichen 128 macht das Board hier, d.h. der ist behebbar.

    Quellcode

    1. Windowtitle "Zugriffstest auf Zeichentabelle zeigt Diskrepanzen"
    2. Font 2:randomize:cls rnd(8^8)
    3. 'set("asmmode",2)
    4. ASM "Zugriffstest",1
    5. mov ecx,code
    6. jmp ecx
    7. Zeichen:
    8. ds "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0A\x0B\x0C\x0D\x0E\x0F"
    9. ds "\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1A\x1B\x1C\x1D\x1E\x1F"
    10. ds " !:#$%&'()*+:-./0123456789::<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^"
    11. ds "_`abcdefghijklmnopqrstuvwxyz{|}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£¤¥"
    12. ds "¦§¨©ª«¬­®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞß"
    13. ds "àáâãäåæçèéêëìíîïðñòóôõö÷øùúûüýþÿ\x00"
    14. code:
    15. xor eax,eax
    16. mov ebx,Zeichen
    17. mov ecx,par1
    18. mov al,[ebx+ecx]
    19. EndASM
    20. print " Anführungszeichen "+chr$(34)+"=34 Komma ,=44 und Strichpunkt ;=59 machen Probleme!\n"
    21. Whileloop 0,255
    22. if &Loop<>Zugriffstest(&Loop)
    23. Print &Loop;":";Zugriffstest(&Loop)
    24. waitinput 1000
    25. endif
    26. endwhile
    27. beep
    28. WaitInput
    Alles anzeigen
  • Mit "Absolut" ist heute nicht eine fixe Speicheradresse gemeint, sondern eine erst zur Laufzeit zugewiesene Adresse. Relative Adressen (besser: Sprungdistanzen) können schon bei Assemblierzeit zugewiesen werden.
    Manchmal hilft es, Befehlsvarianten mit relativer Adressierung zu verwenden. Angeblich gibt es auch einen Assembler, der einen Schalter kennt, um nur relative Adressierungsarten zuzulassen (War das FASM ??)

    JMP weiter erzeugt z.B. den Code E9 JPL0000, nimmt also Laufzeitbezug auf L0000 Weiter. Für manche absoluten Befehle gibt es allerdings keine Ersatzmöglichkeiten.
    Gruss

    P.S.: Von Mitglied Jonathan stammt der Trick, im Assemblerprogramm nach dem absichtlich eingebauten Wert 12345678 zu suchen, um dahinter dann auf einen Datenbereich zuzugreifen. Clever!
  • Aber VORSICHT: Das kann nur mir Assemblercodes funktionieren, in denen keine absoluten Adressen vorkommen. Sobald ein z.B. CALL im Assemblercode vorkommt, geht es nicht mehr!

    Gruß
    Roland
  • Hallo,
    für alle, die noch X3 oder früher haben :
    Hier wäre es schön, wenn bei den veröffentlichten ASM-Procs
    auch die .lst - Datei dabei wäre, die mit Set("ASMMode", 1)
    automatisch erzeugt wird. Zumindest der am Ende erzeugte
    Bytestring. So hätten diese User auch was davon, da sie ja mit
    Call den gefüllten Bereich mit Bytes aufrufen können.

    In Anlehnung daran habe ich mir ein kleines Tool entwickelt,
    das man compiliert sehr gut im Benutzermenü integrieren
    kann.

    Quellcode

    1. Declare Handle btn1, btn2, f, String ASMStr, cnew
    2. Declare Long ende
    3. WindowTitle "Hex - Konvertierer"
    4. Window 600, 400
    5. btn1 = Create("Button", %HWnd, "Convert", 10, 10, 60, 25)
    6. btn2 = Create("Button", %HWnd, "Ende", 10, 60, 60, 25)
    7. UserMessages $10
    8. Clear ende
    9. WhileNot ende
    10. WaitInput
    11. If Clicked(btn1)
    12. ASMStr = Getclip$()
    13. If ASMStr <> ""
    14. cnew = ConvertBytes(ASMStr)
    15. AddWindows " XPROF"
    16. f = FindWindow(GetString$(0, 0))
    17. If f
    18. SendString(f, cnew)
    19. ende = 1
    20. 'MessageBox("In Editor kopiert !", "Info", 0)
    21. EndIf
    22. Else
    23. MessageBox("Bitte zuerst einen String\nin die Zwischenablage kopieren !", "Fehler", 0)
    24. EndIf
    25. ElseIf Clicked(btn2)
    26. ende = 1
    27. EndIf
    28. Case %UMessage = $10 : ende = 1
    29. EndWhile
    30. Proc ConvertBytes
    31. Parameters String bytefeld
    32. Declare String cstr
    33. WhileLoop 1, Len(bytefeld), 2
    34. cstr = cstr + "$" + Mid$(bytefeld, &LOOP, 2) + ","
    35. EndWhile
    36. cstr = Del$(cstr, Len(cstr), 1)
    37. Return cstr
    38. EndProc
    39. End
    Alles anzeigen
    Habe es jetzt nur im XProfed5.0 für X4 probiert. Beim älteren XProfed scheint das Benutzermenü
    nicht zu funktionieren.

    Vielleicht kann es ja jemand gebrauchen bzw. ausprobieren.


  • Zum Thema Assembler und Geschwindigkeit. Der folgende Code errechnet aus zwei Seitenlängen a und b und dem Winkel C (ang) die Seitenlänge c. Die Formel ist hier in XProfan-Schreibweise:

    c = sqrt(a^2 + b^2 - cos(ang) * 2 * a * b)

    (Da in Xprofan c und C die gleiche Variable wären, wurde für den Winkel ang genommen.)

    Brainfuck-Quellcode

    1. CLS
    2. // c^2 = a^2 + b^2 - cos(C)*2*a*b
    3. // C is stored in ang
    4. ASM "Triangle", 3
    5. JMP start
    6. a:
    7. dd 0 // length of side a
    8. b:
    9. dd 0 // length of side b
    10. ang:
    11. dd 0 // opposite angle to side c
    12. c:
    13. dd 0 // the result ? length of side c
    14. bak:
    15. dm 108
    16. start:
    17. mov eax, par1
    18. mov [a], eax
    19. mov eax, par2
    20. mov [b], eax
    21. mov eax, par3
    22. mov [ang], eax
    23. fsave [bak] // aktuellen FPU-Zustand sichern [-|-|-|-|-|-|-|-]
    24. fld [a] // a -> st0 [a|-|-|-|-|-|-|-]
    25. fld st0 // a in st0 + st1 [a|a|-|-|-|-|-|-]
    26. fmul // a^2 -> st0 [a^2|-|-|-|-|-|-|-]
    27. fld [b] // b -> st0 ; a^2 -> st1 [b|a^2|-|-|-|-|-|-]
    28. fld st0 // b in st0 + st1 ; a^2 -> st2 [b|b|a^2|-|-|-|-|-]
    29. fmul // st0 = b^2 ; a^2 -> st1 [b^2|a^2|-|-|-|-|-|-]
    30. fadd // st0 = a^2 + b^2 [a^2+b^2|-|-|-|-|-|-|-]
    31. fld [ang] // angle -> st0 [ang|a^2+b^2|-|-|-|-|-|-]
    32. fcos // st0 = cos(ang) [cos(ang)|a^2+b^2|-|-|-|-|-|-]
    33. fmul [a] // st0 = cos(ang) * a [cos(ang)*a|a^2+b^2|-|-|-|-|-|-]
    34. fmul [b] // st0 = cos(ang) * a * b [cos(ang)*a*b|a^2+b^2|-|-|-|-|-|-]
    35. fld st0 // st0 = cos(ang) * a * b ; st1 = cos(ang) * a * b [cos(ang)*a*b|cos(ang)*a*b|a^2+b^2|-|-|-|-|-|-]
    36. fadd // st0 = cos(ang) * a * b + cos(ang) * a * b = 2(cos(ang) * a * b) [2(cos(ang)*a*b)|a^2+b^2|-|-|-|-|-|-]
    37. fsub // st0 = st1 - st0 = (a^2 + b^2) - (2 * a * b * cos(ang)) [a^2+b^2-2(cos(ang)*a*b)|-|-|-|-|-|-|-]
    38. fsqrt // st0 = sqrt(st0) [sqrt(a^2+b^2-2(cos(ang)*a*b))|-|-|-|-|-|-|-]
    39. fstp [c] // st0 -> c [-|-|-|-|-|-|-|-]
    40. frstor [bak] // FPU-Zustand wiederherstellen
    41. mov eax, [c]
    42. ENDASM
    43. proc PTriangle
    44. Parameters double a, b, ang
    45. return sqrt(a^2 + b^2 - cos(ang) * 2 * a * b)
    46. EndProc
    47. declare long start
    48. declare single c
    49. print
    50. print "Vergleich ohne/mit Assembler"
    51. print "----------------------------"
    52. start = &gettickcount
    53. whileloop 10000
    54. c = PTriangle(4.56, 7.89, 1.5)
    55. endwhile
    56. print c,
    57. print "ohne: " + str$(&gettickcount - start)
    58. start = &gettickcount
    59. whileloop 10000
    60. c = Triangle(4.56, 7.89, 1.5)
    61. endwhile
    62. print c,
    63. print "mit: " + str$(&gettickcount - start)
    64. waitinput
    65. end
    Alles anzeigen

    Um die Zeiten zu vergleichen, wird das Dreieck 10000 mal berechnet. Auf meinem Firmen-Notebook dauert die reine XProfan-Variante ca. 360 Millisekunden und die Assembler-Variante nur ca. 140 Millisekunden.

    Zum besseren Verständnis ist der Code kommentiert und auch der jeweile FPU-Stack angegeben.

    FSAVE und FRSTOR sind hier im Beispiel nicht zwingend notwendig, garantieren aber auch bei verschachteltem Aufruf einen jungfräulichen FPU-Stack, da FSAVE den kompletten FPU-Zustand wegspeichert (es werden dafür mindestens 108 Bytes benötigt) und die FPU initialisiert. Mit FRSTOR wird der ursprüngliche Zustand wieder hergestellt.

    Gruß
    Roland
  • Brackets(Text#, TextLänge%, Funktion%, AusgabePuffer#, AusgabePufferLänge%, Addr(KlammerPaar$))


    In Text# wird der zu untersuchende Text gestellt. Die Textlänge% kann -1 sein, wenn es sich um einen nullterminierten String handelt.
    Funktion% kann folgende Werte annehmen
    -2 ermittelt die Anzahl Klammerpaare, Ausgabepuffer# und AusgabePufferLänge% sollten 0 sein
    -1 ermittelt tiefste Klammerverschachtelung, Ausgabepuffer# und AusgabePufferLänge% sollten 0 sein
    1 .. n ermittelt Text in der angegebenen Klammernummer*, Rückgabewert ist die Verschachtelungsebene dieser Klammer
    KlammerPaar$ ist immer die Adresse eines Strings, der das gesuchte Klammerpaar enthält, also "()" oder "[]" oder "{}"

    Mögliche Fehlerwerte:
    -1 AusgabePuffer zu klein
    -2 Klammern in Text# nicht ausgewogen
    -3 KlammerPaar$ zu kurz (nur 1 Zeichen oder Leerstring)
    -4 KlammerPaar$ enthält zwei identische Zeichen
    -5 mehr als 255 Klammern sind nicht möglich
    -6 Funktion% ungültig (0 oder <-2)
    -7 Gesuchte Klammernummer nicht gefunden
    *Klammern werden immer von links nach rechts nach dem Auftreten der öffnenden Klammer gezählt

    Quellcode

    1. ASM "Brackets", 6
    2. PUSH EBX
    3. PUSH ECX
    4. PUSH EDX
    5. PUSH ESI
    6. PUSH EDI
    7. MOV ESI, Par1 // Eingabezeile
    8. MOV ECX, Par2 // Länge Eingabezeile oder -1
    9. MOV EDX, Par3 // Funktionsauswahl
    10. MOV EDI, Par4 // Ausgabepuffer
    11. MOV EBX, Par5 // Länge Ausgabepuffer
    12. MOV [OutLen], EBX
    13. MOV EBX, Par6 // Klammerstring
    14. JMP Start
    15. FM:
    16. DD 0 // Funktionsnummer oder Klammerzahl bei Kopieren
    17. KE:
    18. DD 0 // Klammerebene bei Kopieren
    19. OutLen:
    20. DD 0 // Merker Ausgabelänge
    21. Count: // Zählt nur die Klammerpaare
    22. NEG EDX
    23. MOV [FM], DL // Funktionsnummer zwischenspeichern
    24. XOR EDX, EDX // Zählregister löschen
    25. XOR EAX, EAX
    26. CS:
    27. LODSB
    28. DEC ECX
    29. JZ CEnde // Stringende erreicht
    30. OR AL, AL // Null-Byte?
    31. JZ CEnde // Ja: Stringende erreicht
    32. CMP AL, BH // Schließende Klammer
    33. JNE NSC
    34. DEC DL // Klammerzahl runterzählen
    35. JS COV // Klammerfehler (Vorzeichen negativ)
    36. NSC:
    37. CMP AL, BL // Öffnende Klammer
    38. JNE CS // Nein: Weitersuchen
    39. INC DL // Klammerzahl hochzählen
    40. INC AH
    41. CMP DL, DH
    42. JL NoBM
    43. MOV DH, DL // und merken, wenn nicht kleiner als bisherige Merkzahl
    44. NoBM:
    45. JMP CS
    46. CEnde:
    47. OR DL, DL
    48. JNZ COV // Klammerzähler <> 0 ist Klammerfehler
    49. MOV DL, [FM] // Funktionsnummer holen
    50. CMP DL, 1 // ist 1?
    51. JZ NBP // Ja, höchste Klammerzahl (Verschachtelungstiefe)
    52. MOV DH, AH // sonst Klammerpaare insgesamt
    53. NBP:
    54. XOR EAX, EAX
    55. MOV AL, DH // Ergebnis nach EAX
    56. JMP Ende // Abgeschlossen mit Klammerzahl in EAX
    57. COV:
    58. MOV EAX, -2 // Fehlercode -2: Klammern nicht ausgewogen
    59. JMP Ende
    60. // ############
    61. All: // Alle Klammerinhalte kopieren
    62. MOV EAX, -6 // Funktion 0 noch nicht implementiert
    63. JMP Ende
    64. // ############
    65. ZahlCopy: // einzelnen Klammerinhalt kopieren, EDX enthält Nummer der Klammer
    66. CMP EDX, 255
    67. JNA ZCCanSeek // gesuchte Klammernummer nicht größer als 255 ist erlaubt
    68. MOV EAX, -5 // ab Klammernummer 256 Fehler -5
    69. JMP Ende
    70. ZCCanSeek:
    71. OR EDI, EDI
    72. JNZ ZCNoMErr
    73. MOV EAX, -1
    74. JMP Ende
    75. ZCNoMErr:
    76. XOR EAX, EAX
    77. MOV AL, [OutLen]
    78. OR AL, AL
    79. JNZ ZCOSeekStart
    80. MOV EAX, -1 // Speicherfehler
    81. JMP Ende
    82. ZCOSeekStart:
    83. MOV AH, DL // zu suchende Klammernummer nach AH
    84. XOR EDX, EDX // Zählregister löschen
    85. MOV [KE], EDX
    86. ZCOSeek:
    87. LODSB
    88. OR AL, AL
    89. JZ ZCFertig1 // Wenn Nullbyte erkannt
    90. DEC ECX
    91. OR ECX, ECX
    92. JZ ZCFertig1 // Wenn Stringlänge durch
    93. CMP AL, BH
    94. JNZ ZCNoSK // keine schließende Klammer
    95. INC DH // schließende Klammer zählen
    96. PUSH EAX
    97. MOV EAX, [KE]
    98. DEC EAX
    99. MOV [KE], EAX
    100. POP EAX
    101. JMP ZCOSeek
    102. ZCNoSK:
    103. CMP AL, BL
    104. JNZ ZCNoOK // keine öffnende Klammer
    105. INC DL // öffnende Klammer zählen
    106. PUSH EAX
    107. MOV EAX, [KE]
    108. INC EAX
    109. MOV [KE], EAX
    110. POP EAX
    111. CMP AH, DL
    112. JE ZCCopy
    113. ZCNoOK:
    114. JMP ZCOSeek
    115. // hier dann Copyroutine, wenn DL = AH
    116. ZCFertig1: // Auffangpunkt Sprungdistanz
    117. JMP ZCFertig // weiterleiten
    118. ZCCopy:
    119. MOV [FM], 0 // Klammerzähler zurücksetzen
    120. ZCCopy1:
    121. LODSB
    122. OR AL, AL
    123. JZ ZCFertig1 // Wenn Nullbyte erkannt
    124. DEC ECX
    125. OR ECX, ECX
    126. JZ ZCFertig1 // Wenn Stringlänge durch
    127. CMP AL, BH
    128. JNZ ZCCNoSK // keine schließende Klammer
    129. INC DH // schließende Klammer zählen
    130. SUB [FM], 1 // gemerkte Klammerzahl runterzählen
    131. JLE CopyEnd // Kopierende
    132. ZCCNoSK:
    133. CMP AL, BL
    134. JNZ ZCSSeek
    135. INC DL // öffnende Klammer zählen
    136. ADD [FM], 1
    137. ZCSSeek:
    138. STOSB
    139. DEC [OutLen]
    140. JNZ ZCCopy1 // Ausgabepuffer nicht voll
    141. MOV EAX, -1 // sonst Speicherfehler
    142. JMP Ende
    143. ZCFertig:
    144. CMP DL, DH
    145. JE ZCNoBErr // öffnende und schließende Klammerzahl gleich
    146. MOV EAX, -2 // sonst Fehler Klammern nicht ausgewogen
    147. JMP Ende
    148. ZCNoBErr:
    149. MOV EAX, -7 // kein Fehler aufgetreten, nichts kopiert
    150. JMP Ende
    151. CopyEnd:
    152. XOR EAX, EAX // Nullbyte an Ausgabe anfügen
    153. STOSB
    154. MOV EAX,[KE] // Verschachtelungstiefe holen
    155. JMP Ende
    156. // ############
    157. Start: // Parameter prüfen und in Funktionsteile verzweigen
    158. OR EBX, EBX // ist Klammerstring 0?
    159. JZ BParErr // Klammerangabe zu kurz oder fehlt
    160. MOV AL, [EBX] // öffnende Klammer nach AL
    161. MOV BH, [EBX + 1] // schließende Klammer nach HB
    162. OR BH, BH // ist schließende Klammer NullByte?
    163. JNZ NoBParErr1 // Nein, kein Fehler
    164. BParErr:
    165. MOV EAX, -3 // Klammerangabe im Parameter zu kurz oder fehlt
    166. JMP Ende
    167. NoBParErr1:
    168. MOV BL, AL // öffnende Klammer nach BL
    169. CMP BL, BH // öffnende und schließende Klammer gleich?
    170. JNZ NoBParErr2 // Nein, kein Fehler
    171. MOV EAX, -4 // beide Klammern gleiches Zeichen
    172. JMP Ende
    173. NoBParErr2:
    174. // hier EDX auswerten und zur jeweiligen Funktion verzweigen
    175. CMP EDX, -1 // Funktion -1 durch Count bearbeitet
    176. JZ CountCall
    177. CMP EDX, -2 // Funktion -2 durch Count bearbeitet
    178. JZ CountCall
    179. // ab hier erst mal Fehler für ungültige Funktionen
    180. OR EDX, EDX
    181. JNZ ZCopy // Funktion 1 .. n
    182. JMP All // Funktion 0
    183. MOV EAX, -6 // sonstige Funktionen noch nicht implementiert
    184. JMP Ende
    185. ZCopy:
    186. JMP ZahlCopy
    187. CountCall:
    188. JMP Count // hier nun Count aufrufen
    189. Ende:
    190. POP EDI
    191. POP ESI
    192. POP EDX
    193. POP ECX
    194. POP EBX
    195. EndASM
    Alles anzeigen

    Gruß Volkmar