1. Dashboard
  2. Mitglieder
    1. Letzte Aktivitäten
    2. Benutzer online
    3. Team
    4. Mitgliedersuche
  3. Forenregeln
  4. Forum
    1. Unerledigte Themen
  • Anmelden
  • Registrieren
  • Suche
Alles
  • Alles
  • Artikel
  • Seiten
  • Forum
  • Erweiterte Suche
  1. AutoIt.de - Das deutschsprachige Forum.
  2. Mitglieder
  3. AspirinJunkie

Beiträge von AspirinJunkie

  • Wie ermitteln dass WMI-Abfrage via ExecQuery leer ist?

    • AspirinJunkie
    • 15. Oktober 2013 um 15:39
    Zitat von mikexmagic

    Aber wie bereits beschrieben liefert .count NUR einen Wert wenn auch die Collection Werte enthält.

    Nein wenn keine Ergebnisse gefunden werden liefert Count den Wert 0 und keinen Fehler.
    Einen Fehler erhälst du wenn du meinen Text nur halb gelesen hast und meinen Hinweis auf die Flags ignoriert hast.

    Zeig also mal ein Minimalskript welches andere bei sich direkt ausführen können um die von dir beschrieben Fehler nachzuvollziehen.

  • Wie ermitteln dass WMI-Abfrage via ExecQuery leer ist?

    • AspirinJunkie
    • 15. Oktober 2013 um 15:29

    Du brauchst keinen eigenen Zähler zu implementieren.
    Es gibt extra dafür ein Count-Attribut bei den WMI-Mengen.
    Hierzu darf man aber nicht $wbemFlagForwardOnly setzen.

    Beispiel:

    Spoiler anzeigen
    [autoit]

    Global $s_Query = "SELECT * FROM Win32_NetworkAdapter WHERE ServiceName='NETwNs64'"

    [/autoit] [autoit][/autoit] [autoit]

    Global $o_WMI = ObjGet("winmgmts:\\localhost\root\CIMV2")
    Global $o_Items = $o_WMI.ExecQuery($s_Query, "WQL", 0)

    [/autoit] [autoit][/autoit] [autoit]

    If $o_Items.Count > 0 Then
    For $o_Item In $o_Items
    ConsoleWrite($o_Item.Name & @CRLF)
    Next
    Else
    ConsoleWrite("leer" & @CRLF)
    EndIf

    [/autoit]
  • Verschachteltes Scripting.Dictionary Objekt nicht unabhängig

    • AspirinJunkie
    • 13. Oktober 2013 um 02:08

    Das ist der Unterschied der Variablenübergabe per "By Value" und "By Reference".

    $var2.add(1,$var1) gibt dem Element mit dem Key "1" des Dictionaries $var2 einen Verweis auf das Dictionary $var1.
    Das Dictionary $var1 wird weder kopiert noch dessen Werte übertragen - alles was nun in $var2 steht ist ein Verweis auf $var1.
    Das heißt auch alle Änderungen an $var1 bekommt man auch weiterhin durch auslesen von $var2.item(1) mit da dort ja nur auf das andere Dictionary verwiesen wird.

    Was du stattdessen brauchst ist für jedes item von $var2 ein jeweils eigenes Dictionary.
    Das heißt du musst also immer ein neues Dictionary erstellen anstatt immer wieder auf das selbe zu verweisen.

    Zitat von f705185@rppkn.com

    Was mache ich falsch?

    • Variablendeklaration mit Dim macht nur in seltenen Spezialfällen Sinn. In allen anderen sollte man zwecks Eindeutigkeit und Übersichtlichkeit Global und Local verwenden.
    • Für $var3 erstellst du ein neues Dictionary. $var3 erhält damit einen Verweis auf das neu erstellte Dictionary. Danach weist du $var3 als Wert $var2.Item(1) zu was nichts weiter ist als ei n Verweis auf $var1. Damit geht der Verweis auf das neu erstellte Array damit flöten. Kurz: Du brauchst für $var3 kein neues Dictionary erstellen da es so wie du es machst eh nicht verwendet wird.
    • Der Quelltext-Spoiler für deinen Code hier im Thread zu verwenden war schon mal ein guter Anfang. Noch besser wäre der AutoIt-Spoiler mit dem der Code dann noch schöner dargestellt wird.

    Allgemeiner Tipp: Einfach mal per Google über "Call by Value" und "Call by Reference" informieren.

  • _HTML_named_entities2Unicode

    • AspirinJunkie
    • 11. Oktober 2013 um 19:47

    Hehe - AutoIt vereinfacht halt alles.
    Selbst das Schreiben von AutoIt... :)

  • _HTML_named_entities2Unicode

    • AspirinJunkie
    • 11. Oktober 2013 um 19:37

    Nur so: man könnte knapp 500 Zeichen sparen wenn man das Präfix "&" und das Suffix ";" aus den Elementen herausgenommen hätte und unten nur einmal in die For-Schleife gesetzt hätte.
    Ansonsten: Schöne und nützliche Fleißarbeit ;)

    Edit: Hm merke gerade warum ich darauf gekommen bin: Ich hatte das selbst mal so umgesetzt (wandelt aber auch die numerischen Entitäten mit um):

    Spoiler anzeigen
    [autoit]

    Global $s_URL = "http://www.autoit.de"
    Global $s_Source = BinaryToString(InetRead($s_URL), 4)

    [/autoit] [autoit][/autoit] [autoit]

    _ConvertEntities($s_Source)

    [/autoit] [autoit][/autoit] [autoit]

    ConsoleWrite($s_Source)

    [/autoit] [autoit][/autoit] [autoit][/autoit] [autoit]

    ; #FUNCTION# ======================================================================================
    ; Name ..........: _ConvertEntities()
    ; Description ...: Wandelt HTML-Entitäten in einem Quellcode in ihre entsprechenden Zeichen
    ; Syntax ........: _ConvertEntities($sURL)
    ; Parameters ....: $sURL - String in welchem die Entitäten umgewandelt werden sollen
    ; Return values .: nichts (String wird direkt verändert)
    ; Author ........: AspirinJunkie
    ; =================================================================================================
    Func _ConvertEntities(ByRef $s_S)
    Local $o_Dict = ObjCreate("Scripting.Dictionary")
    Local $a_RegExp, $s_T
    Local Static $a_NameEnt[253][2] = [["quot", 34],["amp", 38],["apos", 39],["lt", 60],["gt", 62],["quot", 34],["amp", 38],["apos", 39],["lt", 60],["gt", 62],["nbsp", 160], _
    ["iexcl", 161],["cent", 162],["pound", 163],["curren", 164],["yen", 165],["brvbar", 166],["sect", 167],["uml", 168],["copy", 169], _
    ["ordf", 170],["laquo", 171],["not", 172],["reg", 174],["macr", 175],["deg", 176],["plusmn", 177],["sup2", 178],["sup3", 179], _
    ["acute", 180],["micro", 181],["para", 182],["middot", 183],["cedil", 184],["sup1", 185],["ordm", 186],["raquo", 187], _
    ["frac14", 188],["frac12", 189],["frac34", 190],["iquest", 191],["Agrave", 192],["Aacute", 193],["Acirc", 194],["Atilde", 195], _
    ["Auml", 196],["Aring", 197],["AElig", 198],["Ccedil", 199],["Egrave", 200],["Eacute", 201],["Ecirc", 202],["Euml", 203], _
    ["Igrave", 204],["Iacute", 205],["Icirc", 206],["Iuml", 207],["ETH", 208],["Ntilde", 209],["Ograve", 210],["Oacute", 211], _
    ["Ocirc", 212],["Otilde", 213],["Ouml", 214],["times", 215],["Oslash", 216],["Ugrave", 217],["Uacute", 218],["Ucirc", 219], _
    ["Uuml", 220],["Yacute", 221],["THORN", 222],["szlig", 223],["agrave", 224],["aacute", 225],["acirc", 226],["atilde", 227], _
    ["auml", 228],["aring", 229],["aelig", 230],["ccedil", 231],["egrave", 232],["eacute", 233],["ecirc", 234],["euml", 235], _
    ["igrave", 236],["iacute", 237],["icirc", 238],["iuml", 239],["eth", 240],["ntilde", 241],["ograve", 242],["oacute", 243],["ocirc", 244], _
    ["otilde", 245],["ouml", 246],["divide", 247],["oslash", 248],["ugrave", 249],["uacute", 250],["ucirc", 251],["uuml", 252],["yacute", 253], _
    ["thorn", 254],["yuml", 255],["OElig", 338],["oelig", 339],["Scaron", 352],["scaron", 353],["Yuml", 376],["fnof", 402],["circ", 710], _
    ["tilde", 732],["Alpha", 913],["Beta", 914],["Gamma", 915],["Delta", 916],["Epsilon", 917],["Zeta", 918],["Eta", 919],["Theta", 920], _
    ["Iota", 921],["Kappa", 922],["Lambda", 923],["Mu", 924],["Nu", 925],["Xi", 926],["Omicron", 927],["Pi", 928],["Rho", 929],["Sigma", 931], _
    ["Tau", 932],["Upsilon", 933],["Phi", 934],["Chi", 935],["Psi", 936],["Omega", 937],["alpha", 945],["beta", 946],["gamma", 947], _
    ["delta", 948],["epsilon", 949],["zeta", 950],["eta", 951],["theta", 952],["iota", 953],["kappa", 954],["lambda", 955],["mu", 956], _
    ["nu", 957],["xi", 958],["omicron", 959],["pi", 960],["rho", 961],["sigmaf", 962],["sigma", 963],["tau", 964],["upsilon", 965], _
    ["phi", 966],["chi", 967],["psi", 968],["omega", 969],["thetasym", 977],["upsih", 978],["piv", 982],["ensp", 8194], _
    ["emsp", 8195],["thinsp", 8201],["ndash", 8211],["mdash", 8212],["lsquo", 8216],["rsquo", 8217],["sbquo", 8218], _
    ["ldquo", 8220],["rdquo", 8221],["bdquo", 8222],["dagger", 8224],["Dagger", 8225],["bull", 8226],["hellip", 8230], _
    ["permil", 8240],["prime", 8242],["Prime", 8243],["lsaquo", 8249],["rsaquo", 8250],["oline", 8254],["frasl", 8260], _
    ["euro", 8364],["image", 8465],["weierp", 8472],["real", 8476],["trade", 8482],["alefsym", 8501],["larr", 8592], _
    ["uarr", 8593],["rarr", 8594],["darr", 8595],["harr", 8596],["crarr", 8629],["lArr", 8656],["uArr", 8657],["rArr", 8658], _
    ["dArr", 8659],["hArr", 8660],["forall", 8704],["part", 8706],["exist", 8707],["empty", 8709],["nabla", 8711],["isin", 8712], _
    ["notin", 8713],["ni", 8715],["prod", 8719],["sum", 8721],["minus", 8722],["lowast", 8727],["radic", 8730],["prop", 8733],["infin", 8734], _
    ["ang", 8736],["and", 8743],["or", 8744],["cap", 8745],["cup", 8746],["int", 8747],["there4", 8756],["sim", 8764],["cong", 8773], _
    ["asymp", 8776],["ne", 8800],["equiv", 8801],["le", 8804],["ge", 8805],["sub", 8834],["sup", 8835],["nsub", 8836],["sube", 8838], _
    ["supe", 8839],["oplus", 8853],["otimes", 8855],["perp", 8869],["sdot", 8901],["lceil", 8968],["rceil", 8969],["lfloor", 8970],["rfloor", 8971], _
    ["lang", 10216],["rang", 10217],["loz", 9674],["spades", 9824],["clubs", 9827],["hearts", 9829],["diams", 9830]]

    [/autoit] [autoit][/autoit] [autoit]

    ; Dezimalform:
    $a_RegExp = StringRegExp($s_S, "&#(\d{2,4});", 3)
    If IsArray($a_RegExp) And Not @error Then
    For $i In $a_RegExp
    If Not $o_Dict.Exists("&#" & $i & ";") Then $o_Dict.Add("&#" & $i & ";", Number($i))
    Next
    EndIf
    ; Hexadezimalform:
    $a_RegExp = StringRegExp($s_S, "&#x([[:xdigit:]]{2,4});", 3)
    If IsArray($a_RegExp) And Not @error Then
    For $i In $a_RegExp
    If Not $o_Dict.Exists("&#x" & $i & ";") Then $o_Dict.Add("&#x" & $i & ";", Dec($i))
    Next
    EndIf
    ; Namensform:
    For $i = 0 To 252
    $s_T = "&" & $a_NameEnt[$i][0] & ";"
    If StringInStr($s_S, $s_T, 2) Then
    If Not $o_Dict.Exists($s_T) Then $o_Dict.Add($s_T, $a_NameEnt[$i][1])
    EndIf
    Next
    ; Ersetze die Codes durch ihr entsprechendes Zeichen:
    For $i In $o_Dict.Keys
    $s_S = StringReplace($s_S, $i, ChrW($o_Dict($i)))
    Next
    EndFunc ;==>_ConvertEntities

    [/autoit]
  • Laufwerksbuchstabe mit Seriennummer in Verbindung bringen

    • AspirinJunkie
    • 10. Oktober 2013 um 18:04

    Kurz: Ich verstehe noch nicht wirklich was du genau machen möchtest und wo es jetzt hängt.

    Zitat von DeMonToll

    Um dieses Problem anzugehen kam mir die Idee die Seriennummer auszulesen (mit DriveGetSerial). Denn in meinem jugendlichen Leichtsinn dachte ich dass diese irgendwo in der Registry mit dem aktuellen Laufwerksbuchstaben hinterlegt ist.


    Um mit DriveGetSerial die Seriennummer auszulesen, benötigst du einen Pfad mit Laufwerksbuchstaben.
    Bevor du also die Serial hast, hast du schon den Laufwerksbuchstaben den du eigentlich über DriveGetSerial herausfinden möchtest... ?

    Wenn du allerdings feststellen möchtest ob ein Laufwerk mit einer bestimmten Seriennummer angeschlossen ist kannst du einfach mit DriveGetDrive alle externen Laufwerke ermitteln und einzeln mit DriveGetSerial auf die Seriennummer hin überprüfen.

  • Error Handling bei WMI ExecQuery

    • AspirinJunkie
    • 23. September 2013 um 12:57
    • Die übergebene CallbackFunktion (bei dir "_ErrFunc") sollte einen Parameter besitzen - dann brauchst du nicht die globale $oError-Variable zu nutzen.
    • description bleibt bei WMI-Fehlern leer. Aufschlussreicher wären windescription und number.
    • Bitte erstelle das nächste mal ein direkt lauffähiges(!) Minimalskript welches Jeder direkt bei sich testen kann um den Fehler bei sich nachvollziehen zu können.
  • Windows Major, Minor...

    • AspirinJunkie
    • 13. September 2013 um 09:58

    Über die WMI wäre auch eine Möglichkeit:

    [autoit]

    Global $o_Wmi = ObjGet("winmgmts:\\localhost\root\CIMV2")

    [/autoit][autoit][/autoit][autoit]

    For $i In $o_Wmi.ExecQuery('SELECT Version, BuildNumber, CSDVersion FROM Win32_OperatingSystem', "WQL", 48)
    MsgBox(0, "", "Version: " & $i.Version & @CRLF & "Build-Nummer: " & $i.BuildNumber & @CRLF & "Service Pack: " & $i.CSDVersion)
    Next

    [/autoit]
  • Seitenquellcode einlesen - Problem mit Umlauten

    • AspirinJunkie
    • 12. September 2013 um 12:32

    Du rufst ganz bewusst BinaryToString mit "1" als zweiten Parameter auf - warum?
    Du scheinst dir also sicher zu sein, dass der Quellcode in ANSI-Formatierung vorliegt.
    Das ist aber nicht der Fall.

    Ansonsten wird die Seite zweimal aufgerufen.
    Zudem gehe ich nicht davon aus, dass die Betreiber der Seite möchten dass man mit anderen Programmen als einem Browser auf ihre Inhalte zugreift.

  • Eigene Klassen aus dll laden/instanzen erzeugen

    • AspirinJunkie
    • 10. September 2013 um 11:38

    .Net-Dlls sind keine klassischen C-Schnittstellen-Dlls und können somit nicht so einfach per DLLCall verwendet werden.
    Eine Möglichkeit wurde hier dargestellt: >>DotNETExporter<<
    Damit kann man Funktionen aus einer .Net-Dll ausführen.
    Um direkt Objekte daraus zu erzeugen habe ich mal folgendes gelesen: >>Create a .net class and run it as object from your AutoIt script<<

  • _FileReadToArray Error:2 (leere Datei)

    • AspirinJunkie
    • 10. September 2013 um 07:59

    Um den Fehler zusammen mit anderen zu finden ist es fast unerlässlich ein direkt lauffähiges Minimalskript zu posten mit welchem andere den Fehler bei sich reproduzieren können.
    Das Skript welches du hier gepostet hast erfüllt diese Anforderung nicht weswegen ich dann erst einmal selbst das Skript erweitern musste um es lauffähig zu bekommen.
    Habe es folgendermaßen abgeändert:

    Zum lauffähigen Minimalskript erweitert
    [autoit]

    #include <File.au3>

    [/autoit] [autoit][/autoit] [autoit]

    Global $var2
    Global $var1 = _FileListToArray(@ScriptDir, "*.*", 1)

    [/autoit] [autoit][/autoit] [autoit]

    For $i = 1 To $var1[0]
    If Not _FileReadToArray($var1[$i], $var2) Then
    MsgBox(48, "Read to Array", $var1[$i] & " Error: " & @error)
    ContinueLoop ; Funktioniert nicht!
    Else
    ConsoleWrite("Klappt: " & $var1[$i] & @CRLF)
    EndIf
    Next

    [/autoit]


    So wie das Skript jetzt da steht macht es bei mir exakt das was es soll.
    Und ich denke wenn du es bei dir ausführst wird das ebenso sein.
    Der Hintergrund warum ich so auf ein lauffähiges Minimalskript, welches den Fehler reproduziert, poche, ist dass man beim Minimalisieren des eigentlichen Skriptes meistens feststellt, dass der Fehler am Ende doch woanders lag als eigentlich vermutet.
    Du vermutest z.B. dass das Continueloop fehlerhaft ist.
    Warum kann der Fehler aber nicht in deiner, für uns unbekannten, Funktion _Error() stecken (kommt da ein Exit oder ähnliches vor?)?
    Bei einem Minimalskript hättest du diese Funktion erst einmal entfernt (oder mit gepostet damit andere diese auch testen können) und könntest diese entweder ausschließen oder als Übeltäter überführen.

  • Aktuelles Thema: Serial überprüfen mit MySQL

    • AspirinJunkie
    • 4. September 2013 um 20:04
    Zitat von misterspeed

    Sicher? Wer hindert mich daran SQL Code über deine "UserSerial" IN Variable in die Prozedur einzuschleusen?

    Eine Prozedur (und auch eine Funktion) werden im Server "kompiliert". Die Variablen bekommen dabei einen festen Datentyp (hier einen String).
    Bei der Ausführung wird kein SQL-Code mehr geparst. Die Variablen werden dabei direkt entsprechend ihrem Typ in den Code eingefügt.
    Daher bringt eine SQL-Injection hierbei nichts.
    Wenn man allerdings dynamisches SQL in der Prozedur verwendet dann kann man durchaus noch SQL-Injections unterbringen.
    Das ist hier aber nicht der Fall.

    Zitat von misterspeed

    Haben Prozeduren in MySQL überhaupt einen Rückgabewert oder sollte das nicht eher eine stored function sein?

    Die Prozedur gibt nichts zurück.
    Sie löst lediglich ein Select Statement aus.
    Aber prinzipiell könnte man durchaus statt der Prozedur eine Funktion schreiben welche direkt nur ein True oder False zurück gibt.
    €dit: Für Funktionsaufrufe benötigt man Rechte auf SELECT - das wollen wir hier aber eigentlich vermeiden.


    Edit: Ich hab mal ein solches System umgesetzt (liegt im Anhang).
    Es prüft Name-Seriennumer-Kombinationen. Die Seriennummer muss dabei einer 20stelligen Zahl entsprechen.
    Statt der direkten Daten werden in der Datenbank aber lediglich die Hashes gespeichert.
    So ist sichergestellt, dass ein Auslesen der Datenbank keine Rückschlüsse auf gültige Kombinationen zulässt.

    Auf dem Server muss erst die Datenbank und der Benutzer so erstellt werden wie in der CreateLicenseDB.sql angegeben.
    Dort ist auch beschrieben wie man neue Name-Seriennummer-Kombinationen in die Datenbank einträgt.
    Die zu prüfende Seriennummer liegt dann in der Datei "Lizenz.lic".

    Durch den Aufbau der Datenbank und den beschränkten Userrechten sollte das System auf Datenbankseite sicher sein.
    Lediglich durch Manipulation des AutoItskriptes oder des Kommunikationsweges zwischen Client und Server kann man die Überprüfung noch austricksen.
    Wenn gültige Seriennummern im Umlauf sind, kann man diese einfach durch Entfernen in der Datenbank ungültig machen.
    Zur Erweiterung könnte man noch für jede Hash den letzten Zugriff loggen und die Anzahl der Aufrufe um somit eine illegale Benutzung eines Keys von zu vielen Benutzern aufzudecken.

    Dateien

    Lizenzsystem.zip 6,51 kB – 456 Downloads
  • Aktuelles Thema: Serial überprüfen mit MySQL

    • AspirinJunkie
    • 4. September 2013 um 13:54
    Zitat von Awesome

    Ich würde die MySql Daten nie in ein Programm schreiben.


    Kommt auf die Rechte des Nutzers an.
    Wenn man mit dem eingetragenen User lediglich, wie hier vorgeschlagen, z.B. nur CALL ausführen kann sehe ich kein gravierendes Problem dabei.
    Dann verhält es sich nämlich genauso wie du vorgeschlagen hast.

  • Aktuelles Thema: Serial überprüfen mit MySQL

    • AspirinJunkie
    • 4. September 2013 um 12:53

    Warum lässt du alle Keys auslesen und erst dann einzeln von AutoIt vergleichen?
    Je mehr Keys in der Datenbank stehen umso langsamer wird das ganze.
    Besser wäre es die Überprüfung direkt von MySQL durchführen zu lassen.
    Also z.B. so:

    [autoit]

    _Query($sqlcon, "SELECT COUNT(*) FROM serials WHERE number='" & $serial & "';")

    [/autoit]


    Das hätte zusätzlich den Vorteil, dass die korrekten Serials nie auf den Rechner gelangen und dort ausgelesen werden könnten.

    Allerdings könnte man dann eine Serial immer als richtig deklarieren wenn man z.B. einfach in die serial.txt folgendes schreibt:

    Code
    xyz' OR 1=1


    Da wären wir nämlich schon beim nächsten Problem.
    Der User hat volle Rechte auf Selects - und damit kann er die korrekten Keys abfragen und/oder die dynamischen Abfragen per SQL-Injection austricksen (wie eben demonstriert).
    Die eindeutig bessere Lösung wäre es daher auf dem MySQL-Server einen Nutzer zu erstellen welcher lediglich Rechte auf "Call" (müsste über das Privileg "Execute" gehen) erhält.
    Dessen Zugangsdaten können dann völlig unbedenklich im AutoItskript untergebracht werden.
    Dann erstellt man sich auf dem Server noch folgende Prozedur:

    SQL
    CREATE PROCEDURE check_serial(IN UserSerial	VARCHAR(20))
    	SELECT COUNT(*) FROM serials WHERE number=UserSerial;


    Als Abfrage im AutoItskript verwendet man dann noch lediglich folgendes:

    [autoit]

    _Query($sqlcon, "Call check_serial('" & $serial & "');")

    [/autoit]


    Dann wird das ganze performant, SQL-Injections werden verhindert, und der User hat keine Möglichkeit mehr auf die korrekten Serials zuzugreifen.
    Die einzige Sicherheitslücke besteht dann nur noch in der Veränderung des AutoItskriptes. Auf Datenbankseite ist dann hingegen alles sicher.

  • Msg.exe unter Windows 7

    • AspirinJunkie
    • 30. August 2013 um 23:11

    Kann es sein, dass du unter einem 64Bit Windows arbeitest und dein Skript als 32Bit-Programm ausführst?
    Weil wenn ja wäre es klar warum das nicht klappt - die msg.exe gibt es unter SYSWOW64 nicht.

    Dann klappt übrigens auch ein Shellexecute nicht.

    So sollte es in jedem Fall klappen:

    Spoiler anzeigen
    [autoit]

    ; Umleitung für x86-Programm abschalten:
    DllCall("kernel32.dll", "int", "Wow64DisableWow64FsRedirection", "int", 1)

    [/autoit] [autoit][/autoit] [autoit]

    Run(@WindowsDir & "\System32\msg.exe * Test")

    [/autoit]
  • Dec2Binary Rechner

    • AspirinJunkie
    • 19. August 2013 um 20:11
    Zitat von alpines

    Da ich keine Funktion für eine Ganzzahldivision in AutoIt fand, [...]

    Wenn du noch das StringTrimRight(wandelt die Integerzahl implizit in einen String) durch ein Int() (Bei Abs() bleibt es eine Gleitkommazahl) ersetzt bleibt $iDecimal in der Funktion konsistent vom Typ Integer.
    Dann kannst du Int($iDecimal / 2) durch BitShift($iDecimal,1) ersetzen was einer Integerdivision durch 2 entspricht.

  • Absurder For-Schleifen Verlauf bei floats in 3.3.8.1 (Stable)?

    • AspirinJunkie
    • 3. August 2013 um 09:36
    Zitat von Andy

    Letztendlich bleibt nur übrig, den "genauen" Wertebereich zu definieren bzw. darzustellen!

    [autoit]

    For $i = 2 to 3.5 Step 0.025
    ConsoleWrite( stringformat("$i = %f", $i) & @LF)
    Next

    [/autoit]


    Voila!
    Die Frage bleibt aber, ob der Prozessor richtig rechnet oder das Ergebnis "richtig" dargestellt wird


    Das Ergebnis wird hier lediglich gerundet. Die Standardanzeigegenauigkeit bei printf (also Stringformat) liegt bei 6 Nachkommastellen. Ein "%f" entspricht also implizit einem "%.6f".
    Gibt man z.b. "%.16f" hat man den Fehler wieder drin.
    Daher kann man statt die Stringausgabe auf 6 Stellen zu begrenzen gleich die Zahl auf 6 Nachkommastellen runden um den Fehler zu eliminieren.

  • Absurder For-Schleifen Verlauf bei floats in 3.3.8.1 (Stable)?

    • AspirinJunkie
    • 1. August 2013 um 09:06
    Zitat von minx

    Für AutoIt vielleicht

    Es ist das Verhalten der Hardware und damit unabhängig von Programmiersprache.
    Wenn einfach mit internen festen Datentypen gerechnet wird kommt immer das heraus.

    Beispiel in C:

    Beispiel in C
    Code
    #include <stdio.h>
    
    
    int main(void)
    {
    	double i;
    
    	for(i = 2; i <= 3.5; i += 0.025)
    		printf("%18.14f\n", i);
    
    	return 0;
    }
    Alles anzeigen

    bringt folgende Ausgabe:

    Ausgabe
    Code
    2.00000000000000
    2.02500000000000
    2.05000000000000
    2.07500000000000
    2.10000000000000
    2.12500000000000
    2.15000000000000
    2.17500000000000
    2.20000000000000
    2.22500000000000
    2.25000000000000
    2.27500000000000
    2.30000000000000
    2.32500000000000
    2.35000000000000
    2.37500000000000
    2.40000000000000
    2.42500000000000
    2.45000000000000
    2.47500000000000
    2.50000000000000
    2.52500000000000
    2.55000000000000
    2.57500000000000
    2.60000000000000
    2.62500000000000
    2.65000000000000
    2.67500000000000
    2.70000000000000
    2.72500000000000
    2.75000000000000
    2.77500000000000
    2.80000000000000
    2.82500000000000
    2.85000000000000
    2.87500000000000
    2.90000000000000
    2.92500000000000
    2.95000000000000
    2.97500000000000
    3.00000000000000
    3.02500000000000
    3.05000000000000
    3.07500000000000
    3.10000000000000
    3.12500000000000
    3.15000000000000
    3.17500000000000
    3.20000000000000
    3.22500000000000
    3.25000000000000
    3.27500000000000
    3.30000000000000
    3.32500000000000
    3.35000000000000
    3.37500000000000
    3.40000000000000
    3.42499999999999
    3.44999999999999
    3.47499999999999
    3.49999999999999
    Alles anzeigen

    Es ist sehr hilfreich sich etwas genauer mit der internen Repräsentation von Gleitkommazahlen zu beschäftigen.
    Das kann so manche böse Überraschung ersparen: >>Erläuterungen zu Gleitkommazahlen<<

  • Dos Subst - Verzeichnis als Laufwerksbuchstabe

    • AspirinJunkie
    • 24. Juli 2013 um 15:24

    Was hat das denn mit DOS zu tun?
    DOS gibt es meines Wissens nach seit Windows ME nicht mehr.

    Nun zum eigentlichen Problem:
    Run startet ausführbare Dateien.
    Gibt es eine ausführbare Datei namens "Subst.xxx" ?
    Meines Wissens nach nicht - das ist lediglich ein Befehl des Kommandozeileninterpreters cmd.exe.
    Du musst also erst einmal diesen Interpreter aufrufen damit er den entsprechenden Befehl ausführt.

    Versuche also mal eher folgendes:

    [autoit]

    Run(@ComSpec & " /c " & 'subst E: C:\LW-E', "", @SW_HIDE)

    [/autoit]

    Alternativ könnte es auch sein das ShellExecute cmd.exe-Befehle direkt auswertet - einfach mal testen.
    Interessante Frage könnte auch sein ob Administratorrechte hierfür benötigt werden.

  • OpenCV meets AutoIt

    • AspirinJunkie
    • 18. Juli 2013 um 18:46

    Hab das Skript jetzt nicht selbst getestet aber wenn ich mir den Effekt so ansehe scheint die Breite des Zielbildes etwa 1 Pixel (damit meine ich Farbkanalpixel - kein Ganzpixel) kleiner ist als das zu schreibende Bild.
    Vielleicht auch unterschiedliche Anzahl/Größe der Farbkanäle?

Spenden

Jeder Euro hilft uns, Euch zu helfen.

Download

AutoIt Tutorial
AutoIt Buch
Onlinehilfe
AutoIt Entwickler
  1. Datenschutzerklärung
  2. Impressum
  3. Shoutbox-Archiv
Community-Software: WoltLab Suite™