1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
|
discard """
output: '''
12false3ha
21
optimized
'''
"""
import macros, pegs
block arglist:
proc f(x: varargs[string, `$`]) = discard
template optF{f(x)}(x: varargs[untyped]) =
writeLine(stdout, x)
f 1, 2, false, 3, "ha"
block tcse:
template cse{f(a, a, x)}(a: typed{(nkDotExpr|call|nkBracketExpr)&noSideEffect},
f: typed, x: varargs[typed]): untyped =
let aa = a
f(aa, aa, x)+4
var
a: array[0..10, int]
i = 3
doAssert a[i] + a[i] == 4
block hoist:
template optPeg{peg(pattern)}(pattern: string{lit}): Peg =
var gl {.global, gensym.} = peg(pattern)
gl
doAssert match("(a b c)", peg"'(' @ ')'")
doAssert match("W_HI_Le", peg"\y 'while'")
block tmatrix:
type
TMat = object
dummy: int
proc `*`(a, b: TMat): TMat = nil
proc `+`(a, b: TMat): TMat = nil
proc `-`(a, b: TMat): TMat = nil
proc `$`(a: TMat): string = result = $a.dummy
proc mat21(): TMat =
result.dummy = 21
macro optOps{ (`+`|`-`|`*`) ** a }(a: TMat): untyped =
result = newCall(bindSym"mat21")
#macro optPlus{ `+` * a }(a: varargs[TMat]): expr =
# result = newIntLitNode(21)
var x, y, z: TMat
echo x + y * z - x
block tnoalias:
template optslice{a = b + c}(a: untyped{noalias}, b, c: untyped): typed =
a = b
inc a, c
var
x = 12
y = 10
z = 13
x = y+z
doAssert x == 23
block tnoendlessrec:
# test that an endless recursion is avoided:
template optLen{len(x)}(x: typed): int = len(x)
var s = "lala"
doAssert len(s) == 4
block tstatic_t_bug:
# bug #4227
type Vector64[N: static[int]] = array[N, int]
proc `*`[N: static[int]](a: Vector64[N]; b: float64): Vector64[N] =
result = a
proc `+=`[N: static[int]](a: var Vector64[N]; b: Vector64[N]) =
echo "regular"
proc linearCombinationMut[N: static[int]](a: float64, v: var Vector64[N], w: Vector64[N]) {. inline .} =
echo "optimized"
template rewriteLinearCombinationMut{v += `*`(w, a)}(a: float64, v: var Vector64, w: Vector64): auto =
linearCombinationMut(a, v, w)
proc main() =
const scaleVal = 9.0
var a, b: Vector64[7]
a += b * scaleval
main()
|