12 replies to this topic

[nimda]

Exhibit A, you are not defining the return value; it should be UPtr. You are passing two parameters; you should only be passing one: a POIT structure. I believe that the other exhibits in this post likewise don't show any bugs in AHK and this topic should be moved to Ask for Help.

[nimda]

Specifying the return type doesn't make a difference, eg:

You are passing two parameters; you should only be passing one: a POIT structure.

[fragman]

You create structs by using NumPut/NumGet and the offset memory address. Alternatively, feel free to use a struct library, there are some on this forum.

[just me]

MSDN:
The __fastcall model uses registers for the first four arguments and the stack frame to pass the other parameters.
...
The x64 Application Binary Interface (ABI) is a 4 register fast-call calling convention, with stack-backing for those registers. There is a strict one-to-one correspondence between arguments in a function, and the registers for those arguments. Any argument that doesn’t fit in 8 bytes, or is not 1, 2, 4, or 8 bytes, must be passed by reference. There is no attempt to spread a single argument across multiple registers.

Help File:
DllCall:
ErrorLevel:
An (the letter A followed by an integer n): The function was called but was passed too many or too few arguments. "n" is the number of bytes by which the argument list was incorrect. If n is positive, too many arguments (or arguments that were too large) were passed, or the call requires CDecl. If n is negative, too few arguments were passed. This situation should be corrected to ensure reliable operation of the function. The presence of this error may also indicate that an exception occurred, in which case the function returns a blank value. Note that due to the x64 calling convention, 64-bit builds never set ErrorLevel to An.

IMHO this means:

WindowFromPoint has exactly one 8-byte argument. So it isn't a workaround to pass one "Int64", it's rather a workaround to pass two "Int" arguments to get 8 bytes in 32-bit builts. This "concatenation workaround" won't work in 64-bit builts due to the __fastcall model, because (at least) the first four arguments are passed separate in registers.

DllCall doesn't know the number and types of arguments the function requires, it just passes what is given. So it isn't a bug, when you use a wrong type.

[Lexikos]

just me is correct; what you describe is not a bug. Please confirm you have seen this post so that a moderator can move the thread from Bug Reports to Ask for Help.

The following shows the correct usage of WindowFromPoint (assuming x and y are always within the bounds of a 32-bit integer).

Loop {
    CoordMode Mouse
    MouseGetPos x, y
    hwnd := DllCall("WindowFromPoint", "int64", x | y << 32, "ptr")
    WinGetTitle title, ahk_id %hwnd%
    WinGetClass class, ahk_id %hwnd%
    ToolTip %title% ahk_class %class%
    Sleep 10
}

For structures larger than 64-bit, you are forced to use different code for 32-bit and 64-bit builds. However, I have a tentative plan to add support for structures of any arbitrary size. If you have any suggestions (such as what the syntax should be), please start a new thread in the Wish List forum.

This "concatenation workaround" won't work in 64-bit builts due to the __fastcall model, because (at least) the first four arguments are passed separate in registers.

DllCall passes all parameters on the stack. For x64, the first four parameters are additionally stored in the following registers as per the x64 calling convention: rcx, rdx, r8, r9, xmm0, xmm1, xmm2 and xmm3. (The last four are for floating-point values, but all eight are set for simplicity.)

Is there any way to specify or verify the calling convention used by DllCall()?

For x64, there is only one calling convention. Otherwise, you can specify "Cdecl" in DllCall's final parameter to use that calling convention or omit it to use stdcall.

Or is there any way to affect how parameters get pushed onto the call stack or registers, for example whether small variables get zero-extended, etc?

Parameters are pushed onto the stack according to the calling convention and parameter types that you specify.

Since AutoHotkey uses int64 natively, input values are not extended and are only truncated as much as necessary to fit into the parameter list. In other words, all integer types behave the same, with the exception of (U)Int64 on 32-bit builds. (There is no need to truncate to anything smaller than a pointer; if a function accepts a Char, that implies it will use only the low 8 bits of that parameter.)

On the other hand, output values are zero-extended or sign-extended as appropriate for the type which you specify.

[Lexikos]

However, this technique doesn't seem to work for x64 AHK_L.

just me already gave you the answer. Hint: VARIANT is not 1, 2, 4 or 8 bytes.

[Note]

[just me]

But with x64 AHK_L, the int is actually 64 bits as you mentioned

No, an "Int" has 32 bits in both builds.

Alternatively, maybe there is some way to restrict the "int" to only 32 bit values to keep things consistent with windows api?

There is, of course:

x := Numget(Point, 0, "[color=red]Int[/color]")
y := Numget(Point, 4, "[color=red]Int[/color]")

(The default type argument of NumGet() is "UPtr" which is 8 bytes on 64-bit builds)

[chaidy]

suggest CSCode class for SCODE bitfield structure
http://msdn.microsof...y/bb415337.aspx
[attachment=51:SCODE structure.jpg]

; CStruct.ahk - http://www.autohotkey.com/community/viewtopic.php?f=2&t=84054
#include CStruct.ahk
#SingleInstance Force

^\::ExitApp

F12::
	DllCall("LoadLibrary",Str,"oleacc", Ptr)
	
	Point := new CPoint
	DllCall("GetCursorPos", Ptr, Point[""])
	
	VarSetCapacity(varChild, 8)
	DllCall("oleacc\AccessibleObjectFromPoint", "int64", Point.int64, ptrp, pAccessible, ptr, &varChild)   
	
	; get vtable for IAccessible
	vtAccessible :=  NumGet(pAccessible+0, "ptr")
	
	; call get_accName() through the vtable
	scode := new CSCode
	scode.ulong := DllCall(NumGet(vtAccessible+0, 10*A_PtrSize, "ptr"), ptr, pAccessible,"int64", 3, "int64", 0,"int64", 0, ptrp, pvariant) 
	; variant's type is VT_I4 = 3
	; variant's value is CHILDID_SELF = 0
	
	; get_accName returns the following hresult error with 64 bit ahk
	; facility = 7  : "win32"
	; code 1780 : "RPC_X_NULL_REF_POINTER"
	MsgBox % "facility = " scode.facility  "`ncode = " scode.code
return


;=======================================================================
; http://msdn.microsoft.com/en-us/library/bb415337.aspx
; The SCODE data-type is a 32-bit value that specifies a particular warning or error code.
class CSCode extends CStruct_Base
{
   __New()
   {
      this.AddStructVar("code"    , "ULONG", "bit:16")
      this.AddStructVar("facility", "ULONG", "bit:12")
      this.AddStructVar("r"       , "ULONG", "bit:1")
      this.AddStructVar("c"       , "ULONG", "bit:1")
      this.AddStructVar("sev"     , "ULONG", "bit:2")
      this.SetStructCapacity()
   }
   __Get(name)
   {
      if name=ulong
         return NumGet(base.GetData("ptr"), "ULONG")
   }
   __Set(name, v)
   {
      if name=ulong
         return v  ,  NumPut(v+0, base.GetData("ptr"), "ULONG")
   }
}