code_arg wrote:
type
0: literal text or an expression.
1: an input variable.
2: an output variable.
...
For dynamic input/output vars, param should be zero. code_arg_write and code_arg_deref are used to write text or derefs into the arg.
For normal input/output vars, param must be a pointer to a Var. It is not valid to write text or derefs to the arg.
A demonstration or three:
Code:
LowLevel_init()
cg := code_gen()
ACT_ASSIGN = 1
ACT_ASSIGNEXPR = 2
ACT_LISTVARS := 205 + (A_AhkVersion>="1.0.48") ; ACT_WHILE puts these off by 1.
ACT_PAUSE := 193 + (A_AhkVersion>="1.0.48")
Loop 3
{
if A_Index<3
{
code_line(cg, ACT_ASSIGNEXPR)
code_arg(cg, 2, 0) ; 2: Output var. 0: Dynamic.
if A_Index=1
{
; Dynamic vars require at least one deref and at least one character
; of text. However, note that *deref* text is otherwise ignored.
; In this example, v cannot be used for more than one variable name
; since the code has a reference to v, not its contents.
code_arg_deref(cg, " ", __getVar(v:="SomeVar"))
}
else
{
; In this example, we get around the "at least one deref" rule by
; using a global empty variable, which can be used repeatedly.
; Each time the code is run, it will *dynamically* access "SomeVar".
code_arg_write(cg, "SomeOtherVar")
code_arg_deref(cg, "", __getVar(EmptyVar))
}
}
else
{
; Note that ACT_ASSIGNEXPR was used above even though we aren't really
; using an expression. If we use ACT_ASSIGN, AutoTrim affects the result:
code_line(cg, ACT_ASSIGN)
; In this example, we resolve the variable reference at run-time, but
; before the code is run. We could've done __getVar(SomeVar), but that
; would create a global variable at load-time; the first iteration (above)
; would then have accessed this global variable instead of creating a local.
v=SomeVar
code_arg(cg, 2, __getVar(%v%))
}
/* ; THE FOLLOWING REQUIRES v1.0.47.06 OR EARLIER:
code_arg(cg, 0, true) ; true: "Yes, it's an expression."
code_arg_write(cg, """SomeText""")
*/ ; OTHERWISE:
; This arg is not an expression. Expressions in string form aren't supported
; in AutoHotkey v1.0.48 or later, though tokenized expressions can be constructed.
code_arg(cg)
code_arg_write(cg, " SomeText ")
code_line(cg, ACT_LISTVARS)
code_line(cg, ACT_PAUSE)
if hcode := code_finalize(cg)
{
code_run(hcode)
code_delete(hcode)
}
}
code_gen_delete(cg)
Note that in the above, dynamic variables weren't really necessary. Instead, code_var can be used to create a variable to be inserted into the code. However, variables created this way cannot appear in the global variable list. Our dynamic code runs directly inside a function created by code_run; since this function is private to code_run we can't add the var to it's local variable list either.
For an interesting effect, add this to code_run:
Code:
__addVar(code_var("HELLO!"), &cb_func)
Notice that it bypasses normal variable naming rules:
- Any characters can be used.
- Any number of characters can be used, including zero or 1000.
- Any two or more variables can have the same name.
Variables with rule-breaking names may not be accessible by conventional means.
Quote:
help
There was no need to bump; I was in the middle of writing this post. Also, there was no point: if I ignored you the first time, I'd more than likely ignore you the second time.
Login
Register
FAQ
Search
Sorry to be a pain, I will try to understand __Call(), __curry() and adviseUDF() and will get back if I face any problems, OK 
