AutoHotkey Community

; requires ahkv1.48+
; huge thanks to Lexikos.
adviseUDF(advice, type, advisee)  ; type = before or after
{
    static ACT_EXPRESSION:=3, _sizeof_FuncParam:=16, _Var_Name:=24
        , _JumpToLine:=4, _Param:=8, _ParamCount:=12, _MinParams:=16, _IsBuiltIn:=49
        , pn:="1,2,3,4,5,6,7,8,9,10", SYM_INVALID:=56, SYM_VAR:=3, SYM_FUNC:=55, SYM_OPERAND:=4, VAR_ALIAS:=0
        , count = 0

    ErrorLevel := ErrorLevel  ; As of v1.0.48.02, this line is omitted from ListLines. Its
    ListLines Off             ; presence allows the line which called adviseUDF() to be seen.   
    LowLevel_init()

    ; Resolve functions and validate.
    If !(advice_func := __findFunc(advice))
        || !(advisee_func := __findFunc(advisee))
        || NumGet(advisee_func+_IsBuiltIn,0,"char")
    {
        ListLines On
        return false
    }
    param_count := NumGet(advisee_func+_ParamCount)

    ; Begin generating code.
    cg := code_gen()

    ; Begin a standalone expression. Each standalone expression has only one arg.
    eline := code_line(cg, ACT_EXPRESSION )
    code_arg(cg, 0, 1)
    code_line_end(cg)
    arg := NumGet(eline+0, 4)

    ; postfix%count% must fit one ExprTokenType for each param, followed by a SYM_FUNC token
    ; representing a function call, a SYM_INVALID token terminating the expression and
    ; a DerefType holding a pointer to the function to call.
    count += 1
    __static(postfix%count%), __static(text%count%:="[advise " advice " " type " " advisee "]")
    VarSetCapacity(postfix%count%, 16*(param_count+2)+12, 0) ; 16*(MAX_PARAMS+2) + 12*1
    this_postfix := &postfix%count%
    param := NumGet(advisee_func+_Param)
    pc := 0
    Loop, % param_count
    {
        ; Ignore any parameters beyond the function's capacity.
        If (pc >= NumGet(advice_func+12))
            break

        var := NumGet(param+0)
        ; Resolve ByRef/alias.
        If (NumGet(var+23,0,"char") = VAR_ALIAS)
            var := NumGet(var+12)

        ; Put param var into postfix%count% array.
        NumPut(var, this_postfix+0), NumPut(SYM_VAR, this_postfix+8)

        ; Move to next token in postfix%count% array, increment param count.
        this_postfix += 16
        pc++
        param += _sizeof_FuncParam

    }

    ; Set up the DerefType at the end of the postfix%count% array.
    func_deref := this_postfix+32
    NumPut(advice_func, func_deref+4)
    NumPut(pc, func_deref+9, 0, "char")

    ; Set up SYM_FUNC token.
    NumPut(func_deref, this_postfix+0)
    NumPut(SYM_FUNC, this_postfix+8)
    this_postfix += 16

    ; Terminate postfix%count% array.
    NumPut(SYM_INVALID, this_postfix+8)

    ; Set postfix%count% array of the first arg of 'return' below.
    NumPut(&postfix%count%, arg+12)
    NumPut(&text%count%, arg+4)

    If (type == "after")
    {
        line1 := Numget(advisee_func+_JumpToLine, 0, "UInt")
        Loop
        {
            lineAct := NumGet(line1+0, 0, "UChar")
            If (lineAct != 102)
                line1 := NumGet(line1+0, 20, "UInt")
            Else
                break
        }

        If (ch := code_finalize(cg))
        {
            ; Insert the code before the first return statement
            code_insert_before(ch, line1)
            code_delete_handle(ch)
        }
    }
    Else
    {
        If (ch := code_finalize(cg))
        {
            ; Insert the code before the jump-to line of the function.
            code_insert_before(ch, NumGet(advisee_func+_JumpToLine))
            ; Re-target the function at the new line.
            NumPut(eline, advisee_func+_JumpToLine)
            code_delete_handle(ch)
        }
    }
    code_gen_delete(cg)
    ListLines On
    return !!ch
}


myFunc("Apple","banana")
adviseUDF("SwapParameters","before","myFunc")
myFunc("Apple","banana")
adviseUDF("EXCLAIM","before","myFunc")
adviseUDF("LogParams","before","myFunc")
myFunc("Apple","banana")
adviseUDF("LogParams","after","threeparams")
threeparams("alpha","bravo","charlie")
ListLines
Pause

threeparams(a,b,c) {
    a=%a%
    return
}
myFunc(A,B) {
    MsgBox 0, myFunc, %A%, meet %B%.
    return
}
Exclaim(ByRef A, ByRef B) {
    StringUpper, A, A
    StringUpper, B, B
}
SwapParameters(ByRef A, ByRef B) {
    C := A
    A := RegExReplace(B,"^\w","$U0")
    B := RegExReplace(C,"^\w","$l0")
}
LogParams(a="", b="", c="") {
    MsgBox 0, LogParams, %a%,%b%,%c%
}

advise(advice, type, advisee)
{
    ; adapted from lexikos code, see posts below.
    static ACT_EXPRESSION:=3, _sizeof_FuncParam:=16, _Var_Name:=16
        , _JumpToLine:=4, _Param:=8, _ParamCount:=12, _MinParams:=16, _IsBuiltIn:=49
    LowLevel_init()
    ; Resolve functions and validate.
    if !(advice_func := __findFunc(advice))
        || !(advisee_func := __findFunc(advisee))
        || NumGet(advisee_func+_IsBuiltIn,0,"char")
        || (param_count := NumGet(advisee_func+_ParamCount)) < NumGet(advice_func+_MinParams)
        return false
    ; Begin generating code.
    cg := code_gen()
    ; Begin a standalone expression. Each standalone expression has only one arg.
    line := code_line(cg, ACT_EXPRESSION), code_arg(cg, 0, true)
    ; Begin function call by adding a function deref.
    code_arg_deref(cg, advice, advice_func, true, param_count)
    ; Write required text for a function call:
    code_arg_write(cg, "(")
    ; Get address of advisee's first parameter (FuncParam).
    param := NumGet(advisee_func+_Param)
    ; For each available parameter,
    Loop %param_count%
    {
        if A_Index > 1
            code_arg_write(cg, ",")
        ; Get Var of this FuncParam.
        param_var := NumGet(param+0)
        ; Add variable deref.
        code_arg_deref(cg, __str(NumGet(param_var+_Var_Name)), param_var, false)
        ; Move to next parameter. (OK if no next parameter; loop will terminate).
        param += _sizeof_FuncParam
    }
    code_arg_write(cg, ")")
    ; Finish generating code.


if (type = "after")
{
  line1 := Numget(advisee_func+_JumpToLine, 0, "UInt")
  loop
  {
  lineAct := NumGet(line1+0, 0, "UChar")
    if (lineAct != 102)
      line1 := Numget(line1+0, 20, "UInt")
    else
      break
  }
 
  {
    if (ch := code_finalize(cg))
    {
      ; Insert the code before the first return statement
      code_insert_before(ch, line1)
      code_delete_handle(ch)
    }
    code_gen_delete(cg)
    return !!ch
  }
}
else
{
    if (ch := code_finalize(cg))
    {
        ; Insert the code before the jump-to line of the function.
        code_insert_before(ch, NumGet(advisee_func+_JumpToLine))
        ; Re-target the function at the new line.
        NumPut(line, advisee_func+_JumpToLine)
        code_delete_handle(ch)
    }
    code_gen_delete(cg)
    return !!ch
  }
 
}

AdviseBIF(advisee, type, advice)
{
    ; adapted from lexikos code, see posts below.
    ; type := "before" or "after"
adviceInstruction := ""
. "B9" mcodeptr(RegisterCallback(advice,"Cdecl",4,1))    ; mov   ecx, ...
. "FFD1"          ; call  ecx
%type% := adviceInstruction
    __mcode(advisee, ""
    . "8B442404"      ; mov   eax,dword ptr [esp+4]
    . "8B08"          ; mov   ecx,dword ptr [eax]
    . "51"            ; push  ecx
    . "FF742410"      ; push  dword ptr [esp+10h]
    . "FF742410"      ; push  dword ptr [esp+10h]
    . "50"            ; push  eax
    . before
    . "B9" mcodeptr(NumGet(__findFunc(advisee)+4))    ; mov   ecx, ...
    . "FFD1"          ; call  ecx
    . after
    . "83C410"        ; add   esp,10h
    . "C3")           ; ret
}

      if (*op_end == '(') // i.e. dynamic function call
      {
         if (infix_count > MAX_TOKENS - 2) // No room for the following symbol to be added (plus the ++infix done that will be done by the outer loop).
            goto abnormal_end;
         ++infix_count;
         // As a result of a prior loop, deref_start = the null-marker deref which terminates the deref list.
         deref_start->is_function = true;
         // param_count was set when the derefs were parsed.
         deref_start->param_count = deref_alloca->param_count;
      //  aspect oriented programming attempt 1.2
char *FuncName = deref_start->func->mName;
char AdviceFuncName[50];
AdviceFuncName[0] = '\0';
strcpy( AdviceFuncName, FuncName );
strncat( AdviceFuncName, "advice", strlen("advice"));

if (g_script.FindFunc(AdviceFuncName) != NULL)
         {   
deref_start->func = g_script.FindFunc(AdviceFuncName);
            }   

         infix[infix_count].deref = deref_start;
         infix[infix_count].symbol = SYM_FUNC;
         
         // postfix processing of SYM_DYNAMIC will update deref->func before SYM_FUNC is processed.
      }
      else
         deref_start->is_function = false;
      *target++ = '\0'; // Terminate the name, which looks something like "Array%i%".
      cp = op_end; // Must be done only after above is done using cp: Set things up for the next iteration.
      // The outer loop will now do ++infix for us.
   } // For each deref in this expression, and also for the final literal/raw text to the right of the last deref.

         

myFunc = myFunc
;...
myFunc = myFuncAdvice
;...
%myFunc%()
;...
myFuncAdvice() {
    ;...
    return myFunc()
}

myFunc("Apple","banana")
advise("SwapParameters","before","myFunc")
myFunc("Apple","banana")
ListLines   ; Note lines numbered "000" are dynamic lines.
Pause

myFunc(A,B) {
    MsgBox %A%, meet %B%.
}

SwapParameters(ByRef A, ByRef B) {
    C := A
    A := RegExReplace(B,"^\w","$U0")
    B := RegExReplace(C,"^\w","$l0")
}

advise(advice, type, advisee)
{
    static ACT_EXPRESSION:=3, _sizeof_FuncParam:=16, _Var_Name:=16
        , _JumpToLine:=4, _Param:=8, _ParamCount:=12, _MinParams:=16, _IsBuiltIn:=49
    if type != before
        return false ; not supported.
    LowLevel_init()
    ; Resolve functions and validate.
    if !(advice_func := __findFunc(advice))
        || !(advisee_func := __findFunc(advisee))
        || NumGet(advisee_func+_IsBuiltIn,0,"char")
        || (param_count := NumGet(advisee_func+_ParamCount)) < NumGet(advice_func+_MinParams)
        return false
    ; Begin generating code.
    cg := code_gen()
    ; Begin a standalone expression. Each standalone expression has only one arg.
    line := code_line(cg, ACT_EXPRESSION), code_arg(cg, 0, true)
    ; Begin function call by adding a function deref.
    code_arg_deref(cg, advice, advice_func, true, param_count)
    ; Write required text for a function call:
    code_arg_write(cg, "(")
    ; Get address of advisee's first parameter (FuncParam).
    param := NumGet(advisee_func+_Param)
    ; For each available parameter,
    Loop %param_count%
    {
        if A_Index > 1
            code_arg_write(cg, ",")
        ; Get Var of this FuncParam.
        param_var := NumGet(param+0)
        ; Add variable deref.
        code_arg_deref(cg, __str(NumGet(param_var+_Var_Name)), param_var, false)
        ; Move to next parameter. (OK if no next parameter; loop will terminate).
        param += _sizeof_FuncParam
    }
    code_arg_write(cg, ")")
    ; Finish generating code.
    if (ch := code_finalize(cg))
    {
        ; Insert the code before the jump-to line of the function.
        code_insert_before(ch, NumGet(advisee_func+_JumpToLine))
        ; Re-target the function at the new line.
        NumPut(line, advisee_func+_JumpToLine)
        code_delete_handle(ch)
    }
    code_gen_delete(cg)
    return !!ch
}

Add(A,B) {
return % A - B
}

Msgbox % Add(5,6) 
advise("SwapParameters","before","Add")
Msgbox % Add(5,6)
ListLines   ; Note lines numbered "000" are dynamic lines.
Pause

SwapParameters(ByRef A, ByRef B) {
Global
    C := A
    A := B
    B := C
}

InStr = AdviceMachineCode2
;...
%InStr%(A,B,C)
;...
AdviceMachineCode2(A,B,C) {
    AdviceCallback2(A,B,C)
    return AdviceMachineCode1(A,B,C)
}
AdviceMachineCode1(A,B,C) {
    AdviceCallback1(A,B,C)
    return InStr(A,B,C)
}

AdviceMachineCode2:
    ; Note parameters would be off by 4 bytes because of our "return" address.
    call AdviceCallback2
    jmp AdviceMachineCode1

AdviceMachineCode1:
    call AdviceCallback1
    jmp InStr

extend(func, line)
{
; insert line before at the beginning or end of the {}
; this is advising a function with a command, rather than a function call
}

x := RegisterCallback("f")
MouseMove , 4, 5
return

f()
{
msgbox, test
}

extern UINT __stdcall RegisterCallbackCStub(UINT *params, char *address);
MouseMove(..){
UINT temp = 3876798686;
RegisterCallbackCStub(&temp, "test");
...}

if (func.mInstances > 0) // Backup is needed.
      if (!Var::BackupFunctionVars(func, var_backup, var_backup_count)) // Out of memory.
         return DEFAULT_CB_RETURN_VALUE; // Since out-of-memory is so rare, it seems justifiable not to have any error reporting and instead just avoid calling the function.

// in script.cpp
// added
LRESULT sendAhk(char *msg, char *target)
{
   COPYDATASTRUCT cd;
   int port = 10000;
    cd.dwData = port;
         cd.cbData = sizeof(msg) + 1; 
         cd.lpData = msg;
        WPARAM id = 951753;  // for security
       HWND hHost = FindWindow(NULL, target);
   return SendMessage(hHost, WM_COPYDATA, id, (LPARAM)&cd); 
}

static int NavHook;

__forceinline ResultType Line::Perform()
{...
...
// added
char *Navmsg = g_act[mActionType].Name;

// seems to work without this test anyways, but i'm worried about loops because of advice functions
if (NavHook != 1)
{
NavHook = 1;
sendAhk(Navmsg, g_script.mFileName);  //Naveen IPC between ahkcpp and ahk
NavHook = 0;
}
....case ACT_...
}

LowLevel_init()
AdviseBIF("VarSetCapacity","Debugger")
VarSetCapacity( v:="foo", -1 )

Debugger(aResultToken, aParam, aParamCount, aName)
{
    v := 1 + 1
    ; TODO: More reliable way to determine if we are running on the current beta
    ;       of AutoHotkey. The following works by checking if the integer we set
    ;       was cached as binary; it won't work if SetFormat is used anywhere.
    OFFSET_VAR_NAME := NumGet(__getVar(v)+0) == 2 ? 24 : 16
   
    s := __str(aName)
    Loop % aParamCount
    {
        t := NumGet(aParam+A_Index*4-4)
        sym := NumGet(t+8)
        s .= "`n   [" A_Index "]: "
        if sym = 3 ; SYM_VAR
            s .= __str(NumGet(NumGet(t+0)+OFFSET_VAR_NAME)) " := "
        v := getTokenValue(t+0)
        if (sym=0 || sym=3 || (sym=4 && !NumGet(t+4)))
        {
            StringReplace, v, v, ", "", All
            v = "%v%"
        }
        s .= v
    }
    if A_EventInfo ; Show return value.
        s .= "`n   ret: " getTokenValue(aResultToken+0)
    MsgBox % s
}

AdviseBIF(advisee, advice)
{
    __mcode(advisee, ""
    . "8B442404"      ; mov   eax,dword ptr [esp+4]
    . "8B08"          ; mov   ecx,dword ptr [eax]
    . "51"            ; push  ecx
    . "FF742410"      ; push  dword ptr [esp+10h]
    . "FF742410"      ; push  dword ptr [esp+10h]
    . "50"            ; push  eax

    . "B9" mcodeptr(RegisterCallback(advice,"Cdecl",4,0))    ; mov   ecx, ...
    . "FFD1"          ; call  ecx
    . "B9" mcodeptr(NumGet(__findFunc(advisee)+4))    ; mov   ecx, ...
    . "FFD1"          ; call  ecx
    . "B9" mcodeptr(RegisterCallback(advice,"Cdecl",4,1))    ; mov   ecx, ...
    . "FFD1"          ; call  ecx

    . "83C410"        ; add   esp,10h
    . "C3")           ; ret
}

; The following section is necessary to simultaneously support the current release
; of LowLevel and a pending release, which is compatible only with the current beta
; of AutoHotkey. __getTokenValue and __mcodeptr are included in the pending release.
getTokenValue(token) {
    if _gtv:=__findFunc("__getTokenValue") {
        ; Copy that pseudo-built-in func to avoid going through this process again.
        this:=__getFuncUDF(A_ThisFunc)
        NumPut(NumGet(_gtv+4),this+4)
        NumPut(1, this+49, 0, "char")
    } else {    ; That function doesn't exist, so we must create it:
        __mcode(A_ThisFunc ; COMPILED FOR v1.0.47.06:
        , "8B4424088B008378080175298B008B50088B4C240483FA03750E8"
        . "B00C74108040000008B008901C38951088B1089118B4004894104C3")
    }
    return getTokenValue(token+0)
}
mcodeptr(p) {
    VarSetCapacity(buf, 20), DllCall("msvcrt\sprintf", "str", buf, "str", "%08X"
        , "int", p>>24&255 | (p>>16&255)<<8 | (p>>8&255)<<16 | (p&255)<<24, "cdecl")
    return buf
}