AHK v2: converting/optimizing scripts Topic is solved

[vvhitevvizard]

I finally broke down and adjusted it to use loop parse. I also reindented the code so hopefully I didn't break anything doing that

This version runs as fast as 1-line looper. Absolutely the same timing. Just a side-note: so there is no point in stuffing things in super-long lines for performance increase. Keeping each line shorter than 80-100-120 symbols just makes code more easily maintainable.

[vvhitevvizard]

and this in json.get(): combined conditionals on (a) and removed StrLen(v)

Code: Select all

				: ((c==q) ? (_n:=InStr(_s,q,, n+1),v:=SubStr(_s, n+1, _n-n-1)
						, n:=_n, (kf) && (k:=v, z:=":", u:=1)) ;string literals
					: (_n:=SubStr(_s, n) ~= "[\]\},\s]|$",v:=SubStr(_s, n, _n-1)
						, n+=_n-2, (v is "Number") ? v+=0:E(c, n)) ;number
				, (u) || (a ? (k:=b.Push(v), z:=",]"):(b[k]:=v, z:=",}")))

This patch I liked. =) 828 vs 844. +1.9% (with compact json. I think we should focus on compact json optimizations) and readability increase. before it was:

Spoiler

Code: Select all

: ((c==q) ? (v:=SubStr(_s, n+1, InStr(_s,q,, n+1)-n-1)
						, n+=StrLen(v)+1, (kf) && (k:=v, z:=":", u:=1)) ;string literals
					: (v:=SubStr(_s, n, (SubStr(_s, n) ~= "[\]\},\s]|$")-1)
						, n+=StrLen(v)-1, (v is "Number") ? v+=0:E(c, n)) ;number
				, (u) || (a ? k:=b.Push(v):b[k]:=v, z:=a ? ",]" : ",}"))

Forgive me, but I just replaced _n local var used just inside these 2 branches with d (literal is not used yet). _n is already used as an argument of closure right in the same method and I use names starting with _ underscore as function arguments for consistency (so _ marks them as if they r "Read Only" or for special ByRef treatment).

Code: Select all

				: ((c==q) ? (d:=InStr(_s,q,, n+1),v:=SubStr(_s, n+1, d-n-1)
					, n:=d, (kf) && (k:=v, z:=":", u:=1)) ;string literals
				: (d:=SubStr(_s, n) ~= "[\]\},\s]|$",v:=SubStr(_s, n, d-1)
					, n+=d-2, (v is "Number") ? v+=0:E(c, n)) ;number
				, (u) || (a ? (k:=b.Push(v), z:=",]"):(b[k]:=v, z:=",}")))

[oif2003]

Nice! it's one step closer to perfection!

[vvhitevvizard]

Nice! it's one step closer to perfection!

No doubt. whopping +30% performance increase since 1170 score. And I mind u, first version I posted was already optimized to a great degree.
And code we made together is much much shorter and somewhat even more readable.

[vvhitevvizard]

To proceed with dense lines further, I believe we need a bit higher level of commentary over json.Get() locals:

Code: Select all

;a=flag: simple arr [], n=cur. parsing pos in the json str, c=cur chr, z=next chr(s) expected,
;	v=cur val, k=cur key name, kf=flag: literal key name is allowed as next token
;	d=len of the right val (literal string/number), u=flag: we've got key (not val) at this step
;	s:{} =stack, b:{} =sub-objects/keys for cur level of nesting, p=prototype obj for simple arr []

2.
haha it lacks The Final error handling for enormous level of nestedness.
There is no sanity check for that matter yet and just 10KB json with nested pattern like j:='{"k":[[[[[[[[[[[[[[[]]]]]]]]]]]]]]]}' might crash AHK or even worse.
Small and valid (by json standard, e.g. every open bracket has its closing counterpart) data chunk with ~15 nesting levels like sample above makes noticeable parsing slowdown for output by json.Set(): 1600 vs 375.
Its like x4 as slow. So recursion is baaad for AHK, no exception to the rule here.
But its not the slowdown that bothers me. Some malicious input might break down afk-functioning of scripts. We miss some setting (class key) for nestedness level limit. e.g. json.Nesting:=10
Beautified/Compact output:

[vvhitevvizard]

concept proof with bits holder (just 1 integer using bit shifting and logical OR, AND, XOR) instead of multiple .__Arr keys.
compact input: 844 vs 828. Somewhat slower.
beautified input: 1360 vs 1375 Somewhat faster.
It appears to be faster for non-regular j:='{"k":[[[[[[[[[[[[[[[]]]]]]]]]]]]]]]}' data. 781 vs 828. +5.6% So pure logic (w.o keys inside brackets) is definitely faster. So, for regular data, it should actually win over prev. method by a tiny margin theoretically.
It consumes less memory theoretically. -1 static local. created Array [] objects DONT HAVE .__Arr key! Thats important I think. Should we decide to enumerate and update these imported objects.
New nesting level adding is boiled down to simple s.InsertAt(1,v:={}), no more funny arrays.
But I'm not sure would it supersede the previous routine. Ah, and it added funny stuff like y:=y<<1&~1, y:=y<<1|1, y>>=1

Im pretty sure it would be the fastest and of the lowest memory consumption procedure should I rewrite this logic with assembler using CPU registers

Code: Select all

;parse json string. obj:=json.get(str)
;JSON keys are always "strings", expected values r: number|"string"|{object}|[array]
	Get(ByRef _s){ 
		static q:=Chr(34), x:=q "{[0123456789-" ;json: allowed chars outside strings
		n:=0, k:="", kf:=0, s:=[b:=root:={}], z:="{", y:=0
;a=flag: simple arr [], n=cur. parsing pos in the json str, c=cur chr, z=next chr(s) expected,
;	v=cur val, k=cur key name, kf=flag: literal key name is allowed as next token
;	d=len of the val/literal right string, u=flag: we've got key (not val) at this step
;	s:{} =stack, b:{} =sub-objects/keys for cur level of nesting, p=prototype obj for simple arr []
		while(c:=SubStr(_s, ++n, 1))!==""
			InStr(" `t`n`r", c) || (
				InStr(z, c) || E(c, n), u:=0
				, InStr("}]", c) ? ((s.1=root) && E(c, n)
					, s.RemoveAt(1), b:=s.1, y>>=1, z:=(a:=y&1) ? ",]" : ",}")
				: InStr(",:", c) ? (z:=(kf:=!a && c==",") ? q:x)
				: InStr("{[", c) ? ((c=="{") ? (kf:=1, y:=y<<1&~1, z:=q "}") : (y:=y<<1|1, z:=x "]")
						, s.InsertAt(1,v:={}), a ? k:=b.Push(v):b[k]:=v
						, b:=s.1, a:=y&1)
				: ((c==q) ? (d:=InStr(_s,q,, n+1),v:=SubStr(_s, n+1, d-n-1)
						, n:=d, (kf) && (k:=v, z:=":", u:=1)) ;string literals
					: (d:=SubStr(_s, n) ~= "[\]\},\s]|$",v:=SubStr(_s, n, d-1)
						, n+=d-2, (v is "Number") ? v+=0:E(c, n)) ;number
					, (u) || (a ? (k:=b.Push(v), z:=",]"):(b[k]:=v, z:=",}")))
			)
		return(s.1=root || E(c, n), s[1,""]) ;s.Count()!=1 ;unpaired {}, []
		E(_c,_n)=>this._T("Unexpected char <" _c "> in pos " _n)
	}

[oif2003]

That looks interesting, are you planning on limiting it to say 64 levels? I suppose you can always extend it for more. I messed around with using an array push/pop to track object type, but it was too slow, slower than your implementation.

Also just fooling around with older version of the code...this worked (377 [] pairs), but adding one more pair will fail

Code: Select all

j:='{"k":[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]}'

[vvhitevvizard]

That looks interesting, but are you sure you want to limit it to say 64 levels?

I think 3-4 levels max is regular use. Try to recall when u used 4-dimentional a[x,y,z,w] arrays last time

[vvhitevvizard]

I messed around with using an array push/pop to track object type, but it was too slow, slower than your implementation.

I updated the prev. post. So what do u think: should it supersede the previous routine? Can u optimize something in it?

[oif2003]

One time I used json to store files inside ahk script's block comment section preserving file directory structure. In that situation, being able to go 4 deep is kind of nice. Also I might use json to autoload objects into memory on script load and autosave on exit to give the script a persistent feel without using ini files. Not being limited to a shallow depth like 4 levels would be a nice feature. I think we should stick with the current implementation for now unless we find something that is at least twice as fast. But that is not to say we can't keep trying!

[vvhitevvizard]

One time I used json to store files inside ahk script's block comment section preserving file directory structure. In that situation, being able to go 4 deep is kind of nice. Also I might use json to autoload objects into memory on script load and autosave on exit to give the script a persistent feel without using ini files. Not being limited to a shallow depth like 4 levels would be a nice feature. I think we should stick with the current implementation for now unless we find something that is at least twice as fast. But that is not to say we can't keep trying!

well, yeah. But I think something like 10-15 levels is a sane limit. And cap is 63 (cuz first level bit is wasted with opening bracket - and its always {} type of Array).

btw, with new method, created Array [] objects DONT HAVE .__Arr key any longer! Thats good should we re-use input data for enumerating/etc. these garbage .__Arr keys would require some additional treatment consuming CPU time and memory.

So new version has no severe disadvantages, json.Get() code structure remains clean, and it leaves no garbage in objects. I wish I could optimize it a bit just to be on par with prev method for the test string.

[vvhitevvizard]

Also just fooling around with older version of the code...this worked (377 [] pairs), but adding one more pair will fail

This one just hangs. btw new version throws an exception normally. w/o any additional checkups its hardcoded 64 levels limit. it just overflows bitdata and meets an un-paired bracket eventually. Sanity check is still required.

I think ur 377 "magic number" is due to AHK's stack capacity for nesting objects.
Ive read it before:

The recursive calls will crash AHK (stack overflow) for strings longer than 373 (U64), 587 (U32), and 758 (A32) characters (at least on my system).

[vvhitevvizard]

v1.2.3 with "bitholder" variable and nesting level sanity check for incoming json data. json.Nesting setting.
scores 860..875 vs 828..840 of v1.1. But I think less garbage and complete check is more important for json data than 3-4% of performance for compact json string test. For beautified string test its +1% perf. boost still.

Code: Select all

#SingleInstance force

class json{ ;json.get by coco and heavily modified by vvhitevvizard and oif2003
;json.set by vvhitevvizard and heavily modified by oif2003
;ver 1.2.3

;1) 0=enable indentation and line feed, 1=the most compact representation:
;2) spaces per level, similar to JavaScript's JSON.stringify() 'space' parameter
;	JSON array elements and object members will be pretty-printed with the indent level
;3) Sanity check of input json data for level of nesting. capped at 63
;4) 0=suppress error on built-in object types, just output a class name, e.g.: "File Object"
;5) 0=supress error if the root is not an object:
	static Compact:=0, Space:=4, Nesting:=10, ErrObjType:=0, ErrObj:=0

;"stringify": format [associative] array (object) as JSON string
;str:=json.set(obj). returns empty-line if non-object passed
	Set(_o, _d:="") { ;_d:cur indent
		static q:=Chr(34), t, p
		if !IsObject(_o) ;"string" | number
			return this.ErrObj && this._T("Not an object.")
		(p=this.Space) || t:=indent(p:=this.Space)
			, (this.Compact) ? n:=d:="" : (n:="`n", d:=_d t), VarSetCapacity(s,1024*8)
		try a:=_o._ ;trying to get a unique key
		catch ;"Unknown property" exception means its a built-in inenumerable obj
			return(s:=Type(_o) " Object"
				, (this.ErrObjType) && this._T(s " type is not supported."), "{" q s q "}")
		if(a:=_o.HasKey(_o.Count())){ ;=0: not a linear array
			for i in _o ;loop check for tricky arr, e.g. {"key":0,"2":0}
				if !(a:=i=A_Index)
					break
		} ;flag a=0:associative or sparse (e.g. [1,,3]) array -> to be treated as obj {}
		for k,v in _o ;recursive
			s.=d (a ? "" : q k q ":") (isObject(v) ? this.Set(v, d) 
				: (Type(v)=="String") ? q v q : (Type(v)=="Float") ? Format("{:g}", v) : v) "," n
		return(a ? "[" : "{") (s ? (n RTrim(s, "," n) n _d) : "") (a ? "]" : "}") ;wrap in brackets
		indent(n)=>--n ? indent(n) " ":""
	}

;parse json string. obj:=json.get(str)
;JSON keys are always "strings", expected values r: number|"string"|{object}|[array]
	Get(ByRef _s){ 
		static q:=Chr(34), x:=q "{[0123456789-" ;json: allowed chars outside strings
		n:=0, k:="", kf:=0, s:=[b:=root:={}], z:="{", y:=0
;a=flag: 1:array [], 0:object {}, y=bits for 63 nested levels for a flag
;	n=cur. parsing pos in the json str, c=cur chr, z=next chr(s) expected
;	v=cur val, k=cur key name, kf=flag: literal key name is allowed as next token
;	d=len of the val/literal right string, u=flag: we've got key (not val) at this step
;	s:{} =stack, b:{} =sub-objects/keys for cur level of nesting
		while(c:=SubStr(_s, ++n, 1))!==""
			InStr(" `t`n`r", c,1) || ( ;1=CaseSensitive
				InStr(z,c,1) || E(c, n), u:=0
				, InStr("}]", c) ? ((s.1=root) && E(c, n)
					, s.RemoveAt(1), y>>=1, b:=s.1, z:=(a:=y&1) ? ",]" : ",}")
				: InStr(",:",c,1) ? (z:=(kf:=!a && c==",") ? q:x)
				: InStr("{[",c,1) ? (s.Count()>this.Nesting && E(c, n)
						, (c=="{") ? (kf:=1, y:=y<<1&~1, z:=q "}") : (y:=y<<1|1, z:=x "]")
						, s.InsertAt(1,v:={}), a ? k:=b.Push(v):b[k]:=v, b:=s.1, a:=y&1)
				: ((c==q) ? (d:=InStr(_s,q,1, n+1),v:=SubStr(_s, n+1, d-n-1)
						, n:=d, (kf) && (k:=v, z:=":", u:=1)) ;string literals
					: (d:=SubStr(_s, n) ~= "[\]\},\s]|$",v:=SubStr(_s, n, d-1)
						, n+=d-2, (v is "Number") ? v+=0:E(c, n)) ;number
					, (u) || (a ? (k:=b.Push(v), z:=",]"):(b[k]:=v, z:=",}")))
			)
		return(s.1=root || E(c, n), s[1,""]) ;s.Count()!=1 ;unpaired {}, []
		E(_c,_n)=>this._T("Unexpected char <" _c "> in pos " _n)
	}
	_T(_s){
		throw(_s)
	}
}

; Test runs

j:="
(
{
    "a":[
        111,
        "aa"
    ],
    "amount":101,
    "price":104.2,
    "r1":{
        "misc":12,
        "r2":{
            "type1":11,
            "type2":11
        }
    },
    "type":"ask"
}

)"

j:='{"r1":{"r2":{"type1":11,"type2":11},"misc":12}, "type":"ask","price":104.2,"amount":101, "a":[111,"aa"]}'

n:=20000
t:=A_TickCount
loop(n)
	b:=json.Get(j)
a1:=A_TickCount-t

t:=A_TickCount
loop(n)
	s:=json.Set(b)
a2:=A_TickCount-t

msgbox(clipboard:=a1 "|" a2 "`n`n" s)

[vvhitevvizard]

Another must-have thingie to be optimized (but also converted before that) for AHK v2 is anchor routine. http://www.autohotkey.com/forum/topic4348.html
Interested?
its very old, some files fail to run even with AHK v 1.1. But the concept is truly brilliant.

here is anchor 3.2 of the earliest versions that works for me. For concept sake. I added some commentary from other versions of the script.

anchor test1.ahk

Code: Select all

#SingleInstance, force
#Include %A_ScriptDir%\anchor v3.2.ahk

Gui, 1:+Resize
Gui, 1:Add, Button, Section vBtnAddGroup , +
Gui, 1:Add, Edit,  x+1 ys+1 w200 vEdtGroupName
Gui, 1:Add, Button,  x+1 ys vBtnRemoveGroup, -
Gui, 1:Add, Button, x+40 ys vBtnAddScriptlet, +
Gui, 1:Add, Edit,  x+1 ys+1 w150 vEdtScriptletName
Gui, 1:Add, Button,  x+1 ys vBtnRemoveScriptlet, -
Gui, 1:Add, DropDownList, x+40 ys w150 vDdbScriptletInGroup Sort
Gui, 1:Add, Button, ys vBtnCopyToClipboard, Copy to &Clipboard
Gui, 1:Add, TreeView, xs Section w250 h500 vTrvScriptlets 
Gui, 1:Add, Edit, ys w500 h500 vEdtScriptletData
Gui, 1:Show, %GuiSize1%, %ScriptName%
Return

GuiSize:
;ControlName         ,  xwyh , [ x     w     y     h     or True for MoveDraw]
        Anchor("EdtGroupName"       , " w  ", " 1   , 0.5 ,     ,     ")
        Anchor("BtnRemoveGroup"     , "x   ", " 0.5 , 1   ,     ,     ")
        Anchor("BtnAddScriptlet"    , "x   ", " 0.5 , 1   ,     ,     ")
        Anchor("EdtScriptletName"   , "xw  ", " 0.5 , 0.25,     ,     ")
        Anchor("BtnRemoveScriptlet" , "x   ", " 0.75,     ,     ,     ")
        Anchor("DdbScriptletInGroup", "xw  ", " 0.75, 0.25,     ,     ")
        Anchor("BtnCopyToClipboard" , "x   "                           )
        Anchor("TrvScriptlets"      , " w h", "     , 0.5 ,     , 1   ")
        Anchor("EdtScriptletData"   , "xw h", " 0.5 , 0.5 ,     , 1   ")
return

~*Esc::
GuiClose:
ExitApp

anchor v3.2.ahk:

Code: Select all

Anchor(_c, _a, d:=0){
;controls are moved/resized by a fraction of the amount the gui changes size
;e.g.     New pX := orig. pX  + factor * ( current guiW - orig. guiW )
        static pos
        sig=`n%A_Gui%:%_c%= ;unique prefix to store pos/size

        if(d=1)
		draw:="Draw", d:=1,1,1,1
        else if (!d)
                d:=1,1,1,1
        StringSplit q, d, `,

;on first call for this control, remember original position, size and factor:
        if !InStr(pos, sig){
 ;get pos/size of control
		GuiControlGet p, Pos, %_c%
;store (orig. control pos/size - orig. gui width/height * factor) and factor in one var

		pos:=pos . sig . px-A_GuiWidth*q1 . "/" . pw-A_GuiWidth*q2 . "/"
			. py-A_GuiHeight*q3 . "/" . ph-A_GuiHeight*q4 . "/"
        }
    ;get pos/size string and split into array
        StringTrimLeft p, pos, InStr(pos, sig)-1+StrLen(sig)
        StringSplit p, p, /

        c:="xwyh"
    ;calculate new position and size
        loop parse, c
        if InStr(_a, A_LoopField){
                if(A_Index<3) ;for x/w use current gui width
                        e:=p%A_Index%+A_GuiWidth*q%A_Index%
                else
                        e:=p%A_Index%+A_GuiHeight*q%A_Index% ;otherwise use current gui height
;combine "x/w/y/h"
;with (orig. control pos/size - orig. gui width/height*factor + current gui width/height*factor)
                m = %m%%A_LoopField%%e%
        }

 ;move/resize control to new pos/size
        GuiControl %A_Gui%:Move%draw%, %_c%, %m%
}

and here goes the last, optimized for speed version, that stores its internal data using Numput()/NumGet()

anchor test1.ahk

Code: Select all

;https://searchcode.com/codesearch/view/14704564/

#SingleInstance, force
#Include %A_ScriptDir%\anchor v4.6.ahk

Gui, 1:+Resize
Gui, 1:Add, Button, Section vBtnAddGroup, +
Gui, 1:Add, Edit, x+1 ys+1 w200 vEdtGroupName
Gui, 1:Add, Button, x+1 ys vBtnRemoveGroup, -
Gui, 1:Add, Button, x+40 ys vBtnAddScriptlet, +
Gui, 1:Add, Edit, x+1 ys+1 w150 vEdtScriptletName
Gui, 1:Add, Button, x+1 ys vBtnRemoveScriptlet, -
Gui, 1:Add, DropDownList, x+40 ys w150 vDdbScriptletInGroup Sort
Gui, 1:Add, Button, ys vBtnCopyToClipboard, Copy to &Clipboard
Gui, 1:Add, TreeView, xs Section w250 h500 vTrvScriptlets 
Gui, 1:Add, Edit, ys w500 h500 vEdtScriptletData
Gui, 1:Show, %GuiSize1%, %ScriptName%
Return

GuiSize:
	Anchor("EdtGroupName","w0.5")
	Anchor("BtnRemoveGroup","x0.5")
	Anchor("BtnAddScriptlet","x0.5")
	Anchor("EdtScriptletName","x0.5w0.25")
	Anchor("BtnRemoveScriptlet","x0.75")
	Anchor("DdbScriptletInGroup","x0.75w0.25")
	Anchor("BtnCopyToClipboard","x")
	Anchor("TrvScriptlets","w0.5h")
	Anchor("EdtScriptletData","x0.5w0.5h")
return

~*Esc::
GuiClose:
ExitApp

anchor v4.6.ahk

Code: Select all

;Anchor
;Modified version for AutoHotkey 1.1.*
;Defines how controls should be automatically positioned
;	relative to the new dimensions of a window when resized.
;Parameters:
;cl - a control HWND, associated variable name or ClassNN to operate on
;a - (optional) one or more of the anchors: 'x', 'y', 'w' (width) and 'h' (height),
;	optionally followed by a relative factor, e.g. "x h0.5"
;	r - (optional) true to redraw controls, recommended for GroupBox and Button types
;Examples:
;"xy" ; bounds a control to the bottom-left edge of the window
;"w0.5" ; any change in the width of the window will resize the width of the control on a 2:1 ratio
;"h" ; similar to above but directly proportional to height

Anchor(i, a:="", r:=1){
	static c, cs:=12, cx:=255, cl:=0, g, gs:=8, gl:=0, gpi, gw, gh, z:=0, k:=0xFFFF
	if z=0
		VarSetCapacity(g,gs*99, 0), VarSetCapacity(c,cs*cx, 0), z:=1
	if(!WinExist("ahk_id" . i)){
		GuiControlGet t, Hwnd, %i% ;Retrieves handle of the control
		if(ErrorLevel=0)
			i:=t
		else ControlGet i, Hwnd,, %i% ;???
	}
;WINDOWINFO structure https://msdn.microsoft.com/library/ms632610
;	DWORD cbSize=sizeof(WINDOWINFO)
;	4 RECT rcWindow (left,top,right,bottom)
;	20 RECT rcClient
;	36 DWORD dwStyle
;	40 DWORD dwExStyle
;	44 DWORD dwWindowStatus
;	48 UINT cxWindowBorders
;	52 UINT cyWindowBorders
;	ATOM atomWindowType
;	WORD wCreatorVersion
 ;get parent's windowinfo:
	VarSetCapacity(gi,68,0), DllCall("GetWindowInfo", "uint",gp:=DllCall("GetParent", "uint",i), "ptr",&gi)
	giw:=NumGet(gi,28,"int")-NumGet(gi,20,"int") ;client area`s width: right-left
	gih:=NumGet(gi,32,"int")-NumGet(gi,24,"int") ;client area`s height: bottom-top
	if(gp!=gpi){
		gpi:=gp
		loop %gl%
			if(NumGet(g,cb:=gs*(A_Index-1),"uint")=gp){
				gw:=NumGet(g,cb+4,"short"), gh:=NumGet(g,cb+6,"short"), gf:=1
				break
			}
		if(!gf){
			NumPut(gp,g,gl,"uint"), NumPut(gw:=giw,g,gl+4,"short")
			NumPut(gh:=gih,g,gl+6,"short"), gl+=gs
		}
	}
	ControlGetPos dx,dy,dw,dh,, ahk_id %i%
	loop %cl%
		if(NumGet(c,cb:=cs*(A_Index-1),"uint")=i){
			if(!a){
				cf:=1 ;reset controls' pos flag
				break
			}
			giw-=gw, gih-=gh, as:=1, dx:=NumGet(c,cb+4,"short")
				, dy:=NumGet(c,cb+6,"short")
				, cw:=dw, dw:=NumGet(c,cb+8,"short"), ch:=dh, dh:=NumGet(c,cb+10,"short")
			loop Parse, a, "xywh"
				if(A_Index>1)
					av:=SubStr(a, as, 1), as+=1+StrLen(A_LoopField)
						, d%av%+=(InStr("yh", av) ? gih:giw)*(A_LoopField+0 ? A_LoopField:1)
;SetWindowPos https://msdn.microsoft.com/library/ms633545
;Changes the size, position, and Z order of a child, pop-up, or top-level window
;4=SWP_NOZORDER: Retains the current Z order
			DllCall("SetWindowPos", "uint",i, "uint",0, "int",dx, "int",dy
				, "int",InStr(a,"w") ? dw:cw, "int",InStr(a,"h") ? dh:ch, "int",4)
			if(r)
;RedrawWindow https://msdn.microsoft.com/library/dd162911
;RDW_UPDATENOW|RDW_INVALIDATE:
				DllCall("RedrawWindow", "uint",i, "uint",0, "uint",0, "uint",0x0101)
			return
		}
	if(cf!=1)
		cb:=cl, cl+=cs
	bx:=NumGet(gi,48,"uint") ;border x: cxWindowBorders =4
;border y: win bottom-win top-client area`s height-cyWindowBorders =26
	by:=NumGet(gi,16,"int")-NumGet(gi,8,"int")-gih-NumGet(gi,52,"uint")
	if(cf=1)
		dw-=giw-gw, dh-=gih-gh ;ctrl's width=initial win w-current w
	NumPut(i,c,cb,"uint"), NumPut(dx-bx,c,cb+4,"short"), NumPut(dy-by,c,cb+6,"short")
		, NumPut(dw,c,cb+8,"short"), NumPut(dh,c,cb+10,"short")
	return true
}

Ive just started to convert old 3.2 ver to work with AHK v2. here goes test env. (gui with some gui controls) . the same that I used for AHK 1.1 Anchor versions
anchor test1.ahk2:

Code: Select all

#SingleInstance force
global oo:={}
;#Include %A_ScriptDir%\anchor v3.2.ahk

o:=oo
g:=o[1]:=GuiCreate(" +Resize","test")
g.marginX:=g.marginY:=3

o[4]:=g.Add("button", "section vBtnAddGroup" , "+")
o[5]:=g.Add("edit", "x+1 ys+1 w200 vEdtGroupName")
o[6]:=g.Add("button", "x+1 ys vBtnRemoveGroup" , "-")
o[7]:=g.Add("button", "x+40 ys vBtnAddScriptlet" , "+")
o[8]:=g.Add("edit", "x+1 ys+1 w150 vEdtScriptletName")
o[9]:=g.Add("button", "x+1 ys vBtnRemoveScriptlet", "-")
o[10]:=g.Add("ddl", "x+40 ys w150 vDdbScriptletInGroup Sort")
o[11]:=g.Add("button", "ys vBtnCopyToClipboard", "Copy to &Clipboard")
o[12]:=g.Add("treeview", "xs section w250 h500 vTrvScriptlets")
o[13]:=g.Add("edit", "ys w500 h500 vEdtScriptletData")

g.OnEvent("Close", ()=>ExitApp())
g.OnEvent("Escape", ()=>ExitApp())
g.OnEvent("Size", "Size")
g.Show("AutoSize")
exit

Size(_g, _e, _w, _h){
;	if(_e<0)
;		msgbox(_g.title ":Minimized")
}

[vvhitevvizard]

BTW, I figured out a quick sub-test (to skip even 1st iteration of for-loop test) for non-linear (sparse or associative) arrays:

Code: Select all

a:=[1,2,3,4]
msgbox(a.HasKey(a.Count())) ;=1

a:=[1,2,,4]
msgbox(a.HasKey(a.Count())) ;=0 (not a linear array)

so the next snippet from json.Set() can be optimized for perf.:

Code: Select all

		if(a:=_o.HasKey(_o.Count())){ ;=0: not a linear array
			for i in _o
				if !(a:=i=A_Index)
					break
		} ;flag a=0:associative or sparse (e.g. [1,,3]) array -> to be treated as obj {}

for-loop check is still required for tricky arrays such as

Code: Select all

a:={"key":0,"2":0}
msgbox(a.HasKey(a.Count())) ;=1, but it CANT be exported as [] array, it has a named key!

2.
At some point we might want support for escape characters (at least for escaping double quote itself) and/or non-decimal numbers e.g. with "\u" literals to be back.
but if we DO have a task of storing regex strings to json, I would prefer code/decode them via uuencoding or something and store as a plain literal string.

[vvhitevvizard]

to moderators: Could u pls rename the topic to "AHK v2: converting/optimizing scripts"

[vvhitevvizard]

quest for perfection is not over, my friend. =) And I was dead set on gaining back perf. which was somewhat lost after the additional checkup and bits-manipulation logic in v1.2.2.
InStr():
3rd parameter: CaseSensitive: Integer
If the parameter CaseSensitive is omitted or 0 (false), the search is not case sensitive (the method of insensitivity depends on StringCaseSense); otherwise, the case must match exactly.


That means we have to add 1 as 3rd parameter for every instance of the function (there r 6 of them), e.g.:
InStr(z,c) -> InStr(z,c,1)
for compact json: 860 vs 875 of v1.2.2. +1.75% perf boost
I wish default of InStr() would be "case-sensitive search" tho. Cuz case-insensitive means conversion of both strings
And I modified/added some commentary to the script.
Updated post: https://www.autohotkey.com/boards/searc ... 9&sr=posts to v1.2.3

2.
Actually, a global patameter A_StringCaseSense (Read/write, default is 0) can be set to optimize all string comparisons =, != and InsStr.
oh, nvm, its overcomplicated:
•Expression comparison operators (except ==). However, since the equal-sign operator (=) is always case-insensitive, it uses the Locale mode when StringCaseSense is On, as does the case-insensitive mode of InStr.
•InStr. However, it is not affected when its CaseSensitive parameter is true.

On or 1 (true): String comparisons are case sensitive. This setting also makes the expression equal sign operator (=) and the case-insensitive mode of InStr use the locale method described below.

Off or 0 (false): The letters A-Z are considered identical to their lowercase counterparts. This is the starting default for all scripts due to backward compatibility and performance (Locale is 1 to 8 times slower than Off depending on the nature of the strings being compared).

Locale String comparisons are case insensitive according to the rules of the current user's locale. For example, most English and Western European locales treat not only the letters A-Z as identical to their lowercase counterparts, but also ANSI letters like Ä and Ü as identical to theirs.


so A_StringCaseSense:=0 doesnt make =, != as case-sensitive (disabling under-the-hood hidden case conversion).

[oif2003]

Hey, I've been a little busy and haven't had the chance to read all your posts in detail yet. Before I get busy again I want to show you this quick script I threw together. It parses the script file for C code and uses TCC (https://bellard.org/tcc/) to generate the object file, then it reads it into memory like mcode. Perhaps it can give you a quick way to prototype mcode functions. BTW, I couldn't figure out how to use #includes with this... maybe you can?

Write your C function inside a block like this:

Code: Select all

/*_C func
int main(int a) {
	return a+1;
}
*/

Full code is here:

Code: Select all

/*
	Needs TCC: https://download.savannah.gnu.org/releases/tinycc/tcc-0.9.27-win64-bin.zip
	place script in the same folder as libtcc.dll
*/
#singleinstance force

load_cObject(make_cObject("otest.o"), code)

myfunc(x) => DllCall(&code, "Int", x)
/*_C func
int main(int a) {
	return a+1;
}
*/

t := A_TickCount
x := 0
loop 1000000
	x := myfunc(x)
msgbox(A_TickCount - t " : " x)
	
load_cObject(oName, ByRef code) {
	o := FileRead(A_ScriptDir "\" oName, "RAW")
	,tableAdd := NumGet(o, 0x28, "Ptr")
	,toffset := 0x40
	,padd := NumGet(o, tableAdd + toffset +0x18, "UInt")
	,plen := NumGet(o, tableAdd + toffset +0x20, "UInt")
	,VarSetCapacity(code, plen)
	Loop plen//4
		NumPut(NumGet(o, padd + (A_Index - 1)*4, "UInt"), code, (A_Index-1)*4, "UInt")
	return DllCall("VirtualProtect", "Ptr", &code, "UInt", plen, "UInt", 0x40, "Ptr*" , 0)
}	
	
make_cObject(cObjectName) {
	directory := A_ScriptDir
	
	;read c code
	,startLabel := "/*_C" " func"			
	,endLabel   := "*/"
	,script := fileRead(A_ScriptFullPath)
	,cStart := InStr(script, startLabel) + StrLen(startLabel) + 2
	,cEnd   := InStr(script, endLabel, , cStart + 1)
	,cStr   := SubStr(script, cStart, cEnd - cStart)
	
	;LIBTCC calls
	htcclib := DllCall("LoadLibrary", "Str", directory "\libtcc.dll", "Ptr") 
	,Context := DllCall("libtcc\tcc_new", "Ptr")

	;set path to our include/lib folders
	;~ StrPutVar(directory "\lib", libraryPath)
	;~ StrPutVar(directory "\include", includePath)
	;~ StrPutVar(directory "\include", sysincludePath)
	;~ StrPutVar(directory, tcclibPath)
	;~ DllCall("libtcc\tcc_add_library_path", "Ptr", Context, "Str", libraryPath, "Int")
	;~ DllCall("libtcc\tcc_add_include_path", "Ptr", Context, "Str", includePath, "Int")
	;~ DllCall("libtcc\tcc_add_sysinclude_path", "Ptr", Context, "Str", sysincludePath, "Int")
	;~ DllCall("libtcc\tcc_set_lib_path", "Ptr", Context, "Str", tcclibPath)
	
	;StrPutVar("", options)
	;DllCall("libtcc\tcc_set_options", "Ptr", Context, "Str", options)

	;TCC_OUTPUT_MEMORY       := 1 ; output will be run in memory (default)
	;TCC_OUTPUT_EXE          := 2 ; executable file
	;TCC_OUTPUT_DLL          := 3 ; dynamic library
	,TCC_OUTPUT_OBJ          := 4 ; object file
	;TCC_OUTPUT_PREPROCESS   := 5 ; only preprocess (used internally)
	,DllCall("libtcc\tcc_set_output_type", "Ptr", Context, "UInt", TCC_OUTPUT_OBJ, "Int")
	
	,StrPutVar(cStr, _cStr)
	,DllCall("libtcc\tcc_compile_string", "Ptr", Context, "Str", _cStr, "Int")
	
	,StrPutVar(directory "\" cObjectName, filename)
	,DllCall("libtcc\tcc_output_file", "Ptr", Context, "Str", filename, "Int")
	
	;clean up
	,DllCall("libtcc\tcc_delete", "Ptr", Context)
	,DllCall("FreeLibrary", "Ptr", htcclib)
	
	return cObjectName
	StrPutVar(s, ByRef v) => (VarSetCapacity(v, StrPut(s, "cp0")), StrPut(s, &v, "cp0"))
}

Keep up the good work!

[vvhitevvizard]

Hey, I've been a little busy and haven't had the chance to read all your posts in detail yet.

welcome back

Tiny C Compiler

Very pertinent find u come up with! the reason I havent touched C builders for years is gigabytes of bloatware. AHK is a mere godsend here with a sole 500Kb (after UPX compression) file (and w/o any dependancies) required to run scripts for everyday tasks.

too bad, TCC is x86 ONLY

I used some kind of de-bloated VC2010 (85..200Mb) but it would take time to find it back after so many years passed.
I found it. 109MB .7Z
EDIT: link is deleted. not actual any longer - GCC is better
This one can generate optimized x64 code.
Its portable. Kind of. No installation needed.
And its size can be reduced by deleting huge amount of header (windows.h, etc) files. Cuz true m-code should NOT rely on DLL calls. We can regularly call DLLs via AHK, and m-code idea is to process data (searching, replacing for binary buffers and strings).

There was mcode gen.ahk also and a topic https://autohotkey.com/board/topic/5516 ... ode/page-3,
I messed with it before and tried to get it to work. Here is my edited file I was at (sry some russian comments inside). Alas, Its AHK 1.1 , would be great to convert it for v2

Spoiler

Code: Select all

;https://autohotkey.com/board/topic/55162-mcodegen-easily-transform-cc-code-into-mcode/page-3

#SingleInstance force
#NoEnv

;    FileRead, sCode, code.c
	t:=""
	sCode := "#include <windows.h>`nint MyFunction() {`n`treturn 42;`n}"

	Gui Font,, Courier New
	Gui Font,, Inconsolata
	Gui Font, s10, Consolas
	Gui Add, Edit, xm w850 r15 T8 WantTab vtc, %sCode%
	Gui Add, Edit, w850 r10 T8 WantTab vmc, %sCompiled%
	Gui Font

	Gui Add, Text, Section, % "Platform/Compiler:"
	Gui Add, Radio, Group Checked voCL, % "x86 (default)"
	Gui Add, Radio,, % "x64"

	Gui Add, Text, ys Section, % "Optimization:"
	Gui Add, Radio, voO Checked, % "Maximize speed"
	Gui Add, Radio,, % "Minimize space"
	Gui Add, Radio,, % "Disable optimizations (default)"

	Gui Add, Text, ys Section, % "Processor to optimize for:"
	Gui Add, Radio, vofavor Checked, % "INTEL64"
	Gui Add, Radio,, % "AMD64"
	Gui Add, Radio,, % "blend (default)"

	Gui Add, Text, ys Section, % "Automatic inline expansion:"
	Gui Add, Radio, voOb Checked, % "Enabled"
	Gui Add, Radio,, % "Expand only marked fn"
	Gui Add, Radio,, % "Disabled (default)"

	Gui Add, Text, ys Section, % "Intrinsic functions:"
	Gui Add, Radio, voOi Checked, % "Disabled"
	Gui Add, Radio,, % "Enabled (default)"

;	Gui Add, Text, ys Section, % "Code language:"
;	Gui Add, Radio, voT Checked, C
;	Gui Add, Radio,, C++
	Gui Add, Text, ys, % "Warnings generated:"
	Gui Add, Radio, voW Checked, % "Level 1"
	Gui Add, Radio,, % "Level 2"
	Gui Add, Radio, ys -0x10000000,
	Gui Add, Radio,, % "Level 3"
	Gui Add, Radio,, % "Level 4"

	Gui Add, Text, x10 Section, % ":"
	Gui Add, Checkbox, voS Checked, % "use base64 for resulting string"

	Gui Add, Button, ys x700 w150 gbtnCreate, % "Compile to machine code"
;	Gui, Add, Button, x478 y160 h50 w60 gbtnWrap, Wrap the MCode
	Gui Show,, % "MCode generator"

	GuiControl, Focus, tc
	Return

btnWrap:

GuiEscape:
GuiClose:
	FileDelete % name ".cpp"
	FileDelete % name ".obj"
	FileDelete % name ".cod"
	ExitApp

btnCreate:
	Gui Submit, NoHide

        SetWorkingDir %A_Temp%
        name:="code"
        FileDelete % name ".cpp" ;Save code to a temporary file
        FileAppend %tc%, % name ".cpp"

;Prep the parameters:
	x64:=(oCL==1) ? "":"x64"
	;(oT==1 ? "/TC":"/TP") "
	prm:=" /TP /c /FAc /Fa /W" oW " /O" (oO<2 ? "2":(oO<3 ? "1":"d"))
		. " /Ob" (oOb<2 ? "2":(oOb<3 ? "1":"0"))
		. " /Oi" (oOi==1 ? "-":"") " /favor:" (ofavor<2 ? "INTEL64":(ofavor<3 ? "AMD64":"blend"))
	bin:="x:\VC2010"

;        SetWorkingDir %A_ScriptDir%
;	DllCall("AllocConsole")

	RunWait %ComSpec% /c "
(Join&
%bin%\%x64%\set.cmd
%bin%\%x64%\cl.exe "%A_Temp%\%name%.cpp" %prm%
)" , %A_Temp%, Hide

;%bin%%x64%\link.exe /MACHINE:%x64% /DLL /NOENTRY /MAP /NODEFAULTLIB /SUBSYSTEM:WINDOWS /NXCOMPAT /ALIGN:16  "%name%.obj"

;echo `%ERRORLEVEL`%

	;Read the code listing
	FileRead s, % name ".cod"

	;Extract functions. adapted from Lazslo/jamie
	n:=1, t:=""
	;ms) =DotAll+Multiline. m1-fn body , m2-fn name (w/o mangled right side)
	While (n:=RegExMatch(s, "ms)\sPROC\s+(.*?)(\b[\w]+)(@@?\w+?@?)?\w*?\sENDP", m, n)) {
		;wipe out any line that starts in col 1:
		m1:=RegExReplace(m1,"m)^\S.*$")
		; wipe out anything up to and including the first tab character:
;b8 2a 00 00 00	 mov	 eax, 42			; 0000002aH
;c3		 ret	 0
		; wipe out the (now) first tab character and everything after it:
;b8 2a 00 00 00
;c3
		m1:=RegExReplace(RegExReplace(m1,"m)^[^\t]*\t"),"m)\t.*$") 
		;remove all whitespace, upper case
;B82A000000C3
;for x86 and __stdcall fn name might be like this: _MyFunction@0 
;for c: (x64 ? m2:SubStr(m2, 2))
		if (oS) {
                        ;MsgBox % mem_dump(&ss, 32)
			;replace CRLF with literal string continuation:
			m1:=RegExReplace(bin_to_crstr(crstr_to_bin(m1, pp, nn, 4), nn, 1),"\R$")
			m1:=RegExReplace(m1, "\s+(?=\S)","""`n`t. """)
		}
		else
			m1:=toUpper(RegExReplace(m1,"m)\s"))
		t.="M_" m2 "=MCode(""" "" (oS ? "2":"1") "," (x64 ? "x64":"x86") ":" m1 """)`r`n"
		n+=StrLen(m)
	}

	mc.=t
	GuiControl,,mc, %mc%
;	Clipboard:=t

;	if (t)
;		MsgBox % (iParamCount ? name : "The code") " has been successfully compiled!`n"
;			. "The machine code has been placed on the clipboard."
Return


crstr_to_bin(ByRef _s, ByRef _p, ByRef _n, _f) {
	;CRYPT_STRING_ 1=BASE64, 4=HEX, 2=BINARY, 0xa=HEXADDR, 8=HEX_ANY, C=HEXRAW:
	if (!DllCall("crypt32\CryptStringToBinary", "str",_s, "uint",0, "uint",_f
		;=0: calculate len (in bytes), size, skipped, 0
		, "ptr",0, "uint*",_n, "ptr",0, "ptr",0))
		return 0
	VarSetCapacity(_p,_n)
	;_p:=DllCall("GlobalAlloc", "uint",0, "ptr",n, "ptr")
	DllCall("crypt32\CryptStringToBinary", "str",_s, "uint",0, "uint",_f
		, "ptr",&_p, "uint*",_n, "ptr",0, "ptr",0)
        ;DllCall("GlobalFree", "ptr",_p)
	return &_p
}


bin_to_crstr(ByRef _p, _n, _f) {
	if (!DllCall("crypt32\CryptBinaryToString", "ptr",_p, "uint",_n, "uint",_f
		, "ptr",0, "uint*",n))
		return 0
	VarSetCapacity(s,n+1<<A_IsUnicode) ;n=length, not including the terminating null
	DllCall("crypt32\CryptBinaryToString", "ptr",_p, "uint",_n, "uint",_f
		, "ptr",&s, "uint*",n)
	return StrGet(&s)  ;convert to current AHK encoding
}


;*bin data, size, prefix
mem_dump(_b, _n:=0, _p:=" ", _a:=0, _f:="%011x") {
	_n:=_n<1 ? VarSetCapacity(_b):_n  ;Get size of data
	f:=A_FormatInteger
	SetFormat Integer, H
	Loop % _n {
		if (!(A_Index-1&0xF))
			s.=(s ? "`n":"") SubStr(printf(_f, (_a ? _a:_b)),3) ":"
		s.=*(_b++)+256
	}
	StrRep(s,"0x1",_p,"All")
	SetFormat IntegerFast, %f%
	return s
}


printf(_s, _a*) { ;uses variadics to handle variable number of inputs
	;save original integer and float fmt
	local n:=1, i, p, c, v, s, oi, of, m,m1,m2

	if (i:=_a.MaxIndex()) {
		oi:=A_FormatInteger, of:=A_FormatFloat
		;for i, v in _a  ;WARNING: пустые аргументы оператор for пропускает...
		loop % i {
			v:=_a[A_Index]
			;при каждой итерации искать еще не замененые % с начала строки
			if (p:=RegExMatch(_s,"`%(.*?)([d|x|s|f])", m, n)) {  ;m1=format, m2=type
				if (m2=="d"||m2=="x") {
					if v is float
						v:=round(v)  ;round to nearest
					SetFormat IntegerFast, % ((m2=="d") ? "D":"H")
					v+=0
				}
				else if (m2=="f") {
;если пустая строка шла в SetFormat, FloatFast, то выполнялось round():
					if (m1)
						SetFormat FloatFast, %m1%
					v+=0.0
				}
				if (m1<0)
					loop % -m1-StrLen(v)
						v:=v " "
				else if (m1>0) {
					c:=(SubStr(m1,1,1)=="0" ? "0":" ")
					loop % m1-StrLen(v)
						v:=c v
				}
				if (m2=="x"&&c=="0")
					v:="0x" . StrRep(v, "0x")
			}  ;else error, непарный % или его значение в аргументах
			s.=SubStr(_s, n, p-n) v, n:=p+StrLen(m) ;подстр до %, замененная подстр
		}
		_s:=s SubStr(_s, n)  ;докопировать подстр после последнего %
		;restore original integer and float format:
		SetFormat IntegerFast, %oi%
		SetFormat FloatFast, %of%
	}
	return _s
}


toUpper(byRef _s){
	StringUpper _s, _s
	return _s
}


StrRep(ByRef _s, s, r:="", All:="") { ;FIXME: wrap-function works only if InStr=OutStr
	StringReplace _s, _s, %s%, %r%, %All%
	return _s
}

Ill come back to m-coding later.

[vvhitevvizard]

back to pretty-printing procedures. U would be surprised:
task: for stringified float: leading/trailing zeros r truncated, and the decimal point appears only if one or more digits follow it

Code: Select all

SmartT(_a){ ;for float numbers, get rid of leading/trailing 0 and .
	a:="" _a
	if(InStr(a,".")){ ;if decimals
		while(SubStr(a,-1,1)="0")
			a:=SubStr(a,1,-1)
		if(SubStr(a,-1,1)=".")
			a:=SubStr(a,1,-1)
	}
	return a
}
;g:	Leading/trailing zeros are truncated, and the decimal point appears only
;	if one or more digits follow it
SmartT_(_a)=>Format("{:g}", _a)

a:="-0000001.55" ; -> -1.55

n:=200*1000
t:=A_TickCount
loop(n)
	s:=SmartT(a)
a1:=A_TickCount-t

t:=A_TickCount
loop(n)
	b:=SmartT_(a)
a2:=A_TickCount-t

msgbox(clipboard:=a1 "|" a2 "`n`n" s)

150 vs 328. My absolutely unoptimized (at first look) procedure is x2 times as fast compared to Format("{:g}", v)
I knew that Format should be slow. But I didn't expect that scratchy function would be faster. Now I found a bug in it - it fails to remove leading zeroes. But thats another story. And motivation to optimize it