eknkc/amber/runtime.go

package amber

import (
        "encoding/json"
        "fmt"
        "html/template"
        "reflect"
)

var FuncMap = template.FuncMap{
        "__amber_add":   runtime_add,
        "__amber_sub":   runtime_sub,
        "__amber_mul":   runtime_mul,
        "__amber_quo":   runtime_quo,
        "__amber_rem":   runtime_rem,
        "__amber_minus": runtime_minus,
        "__amber_plus":  runtime_plus,
        "__amber_eql":   runtime_eql,
        "__amber_gtr":   runtime_gtr,
        "__amber_lss":   runtime_lss,

        "json":      runtime_json,
        "unescaped": runtime_unescaped,
}

func runtime_add(x, y interface{}) interface{} {
        vx, vy := reflect.ValueOf(x), reflect.ValueOf(y)
        switch vx.Kind() {
        case reflect.Int, reflect.Int32, reflect.Int64, reflect.Int16, reflect.Int8:
                {
                        switch vy.Kind() {
                        case reflect.Int, reflect.Int32, reflect.Int64, reflect.Int16, reflect.Int8:
                                return vx.Int() + vy.Int()
                        case reflect.Float32, reflect.Float64:
                                return float64(vx.Int()) + vy.Float()
                        case reflect.String:
                                return fmt.Sprintf("%d%s", vx.Int(), vy.String())
                        }
                }
        case reflect.Float32, reflect.Float64:
                {
                        switch vy.Kind() {
                        case reflect.Int, reflect.Int32, reflect.Int64, reflect.Int16, reflect.Int8:
                                return vx.Float() + float64(vy.Int())
                        case reflect.Float32, reflect.Float64:
                                return vx.Float() + vy.Float()
                        case reflect.String:
                                return fmt.Sprintf("%f%s", vx.Float(), vy.String())
                        }
                }
        case reflect.String:
                {
                        switch vy.Kind() {
                        case reflect.Int, reflect.Int32, reflect.Int64, reflect.Int16, reflect.Int8:
                                return fmt.Sprintf("%s%d", vx.String(), vy.Int())
                        case reflect.Float32, reflect.Float64:
                                return fmt.Sprintf("%s%f", vx.String(), vy.Float())
                        case reflect.String:
                                return fmt.Sprintf("%s%s", vx.String(), vy.String())
                        }
                }
        }

        return "<nil>"
}

func runtime_sub(x, y interface{}) interface{} {
        vx, vy := reflect.ValueOf(x), reflect.ValueOf(y)
        switch vx.Kind() {
        case reflect.Int, reflect.Int32, reflect.Int64, reflect.Int16, reflect.Int8:
                {
                        switch vy.Kind() {
                        case reflect.Int, reflect.Int32, reflect.Int64, reflect.Int16, reflect.Int8:
                                return vx.Int() - vy.Int()
                        case reflect.Float32, reflect.Float64:
                                return float64(vx.Int()) - vy.Float()
                        }
                }
        case reflect.Float32, reflect.Float64:
                {
                        switch vy.Kind() {
                        case reflect.Int, reflect.Int32, reflect.Int64, reflect.Int16, reflect.Int8:
                                return vx.Float() - float64(vy.Int())
                        case reflect.Float32, reflect.Float64:
                                return vx.Float() - vy.Float()
                        }
                }
        }

        return "<nil>"
}

func runtime_mul(x, y interface{}) interface{} {
        vx, vy := reflect.ValueOf(x), reflect.ValueOf(y)
        switch vx.Kind() {
        case reflect.Int, reflect.Int32, reflect.Int64, reflect.Int16, reflect.Int8:
                {
                        switch vy.Kind() {
                        case reflect.Int, reflect.Int32, reflect.Int64, reflect.Int16, reflect.Int8:
                                return vx.Int() * vy.Int()
                        case reflect.Float32, reflect.Float64:
                                return float64(vx.Int()) * vy.Float()
                        }
                }
        case reflect.Float32, reflect.Float64:
                {
                        switch vy.Kind() {
                        case reflect.Int, reflect.Int32, reflect.Int64, reflect.Int16, reflect.Int8:
                                return vx.Float() * float64(vy.Int())
                        case reflect.Float32, reflect.Float64:
                                return vx.Float() * vy.Float()
                        }
                }
        }

        return "<nil>"
}

func runtime_quo(x, y interface{}) interface{} {
        vx, vy := reflect.ValueOf(x), reflect.ValueOf(y)
        switch vx.Kind() {
        case reflect.Int, reflect.Int32, reflect.Int64, reflect.Int16, reflect.Int8:
                {
                        switch vy.Kind() {
                        case reflect.Int, reflect.Int32, reflect.Int64, reflect.Int16, reflect.Int8:
                                return vx.Int() / vy.Int()
                        case reflect.Float32, reflect.Float64:
                                return float64(vx.Int()) / vy.Float()
                        }
                }
        case reflect.Float32, reflect.Float64:
                {
                        switch vy.Kind() {
                        case reflect.Int, reflect.Int32, reflect.Int64, reflect.Int16, reflect.Int8:
                                return vx.Float() / float64(vy.Int())
                        case reflect.Float32, reflect.Float64:
                                return vx.Float() / vy.Float()
                        }
                }
        }

        return "<nil>"
}

func runtime_rem(x, y interface{}) interface{} {
        vx, vy := reflect.ValueOf(x), reflect.ValueOf(y)
        switch vx.Kind() {
        case reflect.Int, reflect.Int32, reflect.Int64, reflect.Int16, reflect.Int8:
                {
                        switch vy.Kind() {
                        case reflect.Int, reflect.Int32, reflect.Int64, reflect.Int16, reflect.Int8:
                                return vx.Int() % vy.Int()
                        }
                }
        }

        return "<nil>"
}

func runtime_minus(x interface{}) interface{} {
        vx := reflect.ValueOf(x)
        switch vx.Kind() {
        case reflect.Int, reflect.Int32, reflect.Int64, reflect.Int16, reflect.Int8:
                return -vx.Int()
        case reflect.Float32, reflect.Float64:
                return -vx.Float()
        }

        return "<nil>"
}

func runtime_plus(x interface{}) interface{} {
        vx := reflect.ValueOf(x)
        switch vx.Kind() {
        case reflect.Int, reflect.Int32, reflect.Int64, reflect.Int16, reflect.Int8:
                return +vx.Int()
        case reflect.Float32, reflect.Float64:
                return +vx.Float()
        }

        return "<nil>"
}

func runtime_eql(x, y interface{}) bool {
        vx, vy := reflect.ValueOf(x), reflect.ValueOf(y)
        switch vx.Kind() {
        case reflect.Int, reflect.Int32, reflect.Int64, reflect.Int16, reflect.Int8:
                {
                        switch vy.Kind() {
                        case reflect.Int, reflect.Int32, reflect.Int64, reflect.Int16, reflect.Int8:
                                return vx.Int() == vy.Int()
                        case reflect.Float32, reflect.Float64:
                                return float64(vx.Int()) == vy.Float()
                        case reflect.String:
                                return fmt.Sprintf("%d", vx.Int()) == vy.String()
                        }
                }
        case reflect.Float32, reflect.Float64:
                {
                        switch vy.Kind() {
                        case reflect.Int, reflect.Int32, reflect.Int64, reflect.Int16, reflect.Int8:
                                return vx.Float() == float64(vy.Int())
                        case reflect.Float32, reflect.Float64:
                                return vx.Float() == vy.Float()
                        case reflect.String:
                                return fmt.Sprintf("%f", vx.Float()) == vy.String()
                        }
                }
        case reflect.String:
                {
                        switch vy.Kind() {
                        case reflect.Int, reflect.Int32, reflect.Int64, reflect.Int16, reflect.Int8:
                                return vx.String() == fmt.Sprintf("%d", vy.Int())
                        case reflect.Float32, reflect.Float64:
                                return vx.String() == fmt.Sprintf("%f", vy.Float())
                        case reflect.String:
                                return vx.String() == fmt.Sprintf("%s", vy.String())
                        }
                }
        case reflect.Bool:
                {
                        switch vy.Kind() {
                        case reflect.Int, reflect.Int32, reflect.Int64, reflect.Int16, reflect.Int8:
                                return vx.Bool() && vy.Int() != 0
                        case reflect.Bool:
                                return vx.Bool() == vy.Bool()
                        }
                }
        }

        return false
}

func runtime_lss(x, y interface{}) bool {
        vx, vy := reflect.ValueOf(x), reflect.ValueOf(y)
        switch vx.Kind() {
        case reflect.Int, reflect.Int32, reflect.Int64, reflect.Int16, reflect.Int8:
                {
                        switch vy.Kind() {
                        case reflect.Int, reflect.Int32, reflect.Int64, reflect.Int16, reflect.Int8:
                                return vx.Int() < vy.Int()
                        case reflect.Float32, reflect.Float64:
                                return float64(vx.Int()) < vy.Float()
                        case reflect.String:
                                return fmt.Sprintf("%d", vx.Int()) < vy.String()
                        }
                }
        case reflect.Float32, reflect.Float64:
                {
                        switch vy.Kind() {
                        case reflect.Int, reflect.Int32, reflect.Int64, reflect.Int16, reflect.Int8:
                                return vx.Float() < float64(vy.Int())
                        case reflect.Float32, reflect.Float64:
                                return vx.Float() < vy.Float()
                        case reflect.String:
                                return fmt.Sprintf("%f", vx.Float()) < vy.String()
                        }
                }
        case reflect.String:
                {
                        switch vy.Kind() {
                        case reflect.Int, reflect.Int32, reflect.Int64, reflect.Int16, reflect.Int8:
                                return vx.String() < fmt.Sprintf("%d", vy.Int())
                        case reflect.Float32, reflect.Float64:
                                return vx.String() < fmt.Sprintf("%f", vy.Float())
                        case reflect.String:
                                return vx.String() < vy.String()
                        }
                }
        }

        return false
}

func runtime_gtr(x, y interface{}) bool {
        return !runtime_lss(x, y) && !runtime_eql(x, y)
}

func runtime_json(x interface{}) (res string, err error) {
        bres, err := json.Marshal(x)
        res = string(bres)
        return
}

func runtime_unescaped(x string) interface{} {
        return template.HTML(x)
}
Revision:	1.1
Committed:	Mon Sep 30 00:42:06 2024 UTC (6 weeks, 4 days ago) by yakumo_izuru
Branch:	MAIN
CVS Tags:	HEAD
Error occurred while calculating annotation data.
Log Message:	Mirrored from https://git.chaotic.ninja/git/yakumo_izuru/aya
#	Content
1	package amber
2
3	import (
4	"encoding/json"
5	"fmt"
6	"html/template"
7	"reflect"
8	)
9
10	var FuncMap = template.FuncMap{
11	"__amber_add": runtime_add,
12	"__amber_sub": runtime_sub,
13	"__amber_mul": runtime_mul,
14	"__amber_quo": runtime_quo,
15	"__amber_rem": runtime_rem,
16	"__amber_minus": runtime_minus,
17	"__amber_plus": runtime_plus,
18	"__amber_eql": runtime_eql,
19	"__amber_gtr": runtime_gtr,
20	"__amber_lss": runtime_lss,
21
22	"json": runtime_json,
23	"unescaped": runtime_unescaped,
24	}
25
26	func runtime_add(x, y interface{}) interface{} {
27	vx, vy := reflect.ValueOf(x), reflect.ValueOf(y)
28	switch vx.Kind() {
29	case reflect.Int, reflect.Int32, reflect.Int64, reflect.Int16, reflect.Int8:
30	{
31	switch vy.Kind() {
32	case reflect.Int, reflect.Int32, reflect.Int64, reflect.Int16, reflect.Int8:
33	return vx.Int() + vy.Int()
34	case reflect.Float32, reflect.Float64:
35	return float64(vx.Int()) + vy.Float()
36	case reflect.String:
37	return fmt.Sprintf("%d%s", vx.Int(), vy.String())
38	}
39	}
40	case reflect.Float32, reflect.Float64:
41	{
42	switch vy.Kind() {
43	case reflect.Int, reflect.Int32, reflect.Int64, reflect.Int16, reflect.Int8:
44	return vx.Float() + float64(vy.Int())
45	case reflect.Float32, reflect.Float64:
46	return vx.Float() + vy.Float()
47	case reflect.String:
48	return fmt.Sprintf("%f%s", vx.Float(), vy.String())
49	}
50	}
51	case reflect.String:
52	{
53	switch vy.Kind() {
54	case reflect.Int, reflect.Int32, reflect.Int64, reflect.Int16, reflect.Int8:
55	return fmt.Sprintf("%s%d", vx.String(), vy.Int())
56	case reflect.Float32, reflect.Float64:
57	return fmt.Sprintf("%s%f", vx.String(), vy.Float())
58	case reflect.String:
59	return fmt.Sprintf("%s%s", vx.String(), vy.String())
60	}
61	}
62	}
63
64	return "<nil>"
65	}
66
67	func runtime_sub(x, y interface{}) interface{} {
68	vx, vy := reflect.ValueOf(x), reflect.ValueOf(y)
69	switch vx.Kind() {
70	case reflect.Int, reflect.Int32, reflect.Int64, reflect.Int16, reflect.Int8:
71	{
72	switch vy.Kind() {
73	case reflect.Int, reflect.Int32, reflect.Int64, reflect.Int16, reflect.Int8:
74	return vx.Int() - vy.Int()
75	case reflect.Float32, reflect.Float64:
76	return float64(vx.Int()) - vy.Float()
77	}
78	}
79	case reflect.Float32, reflect.Float64:
80	{
81	switch vy.Kind() {
82	case reflect.Int, reflect.Int32, reflect.Int64, reflect.Int16, reflect.Int8:
83	return vx.Float() - float64(vy.Int())
84	case reflect.Float32, reflect.Float64:
85	return vx.Float() - vy.Float()
86	}
87	}
88	}
89
90	return "<nil>"
91	}
92
93	func runtime_mul(x, y interface{}) interface{} {
94	vx, vy := reflect.ValueOf(x), reflect.ValueOf(y)
95	switch vx.Kind() {
96	case reflect.Int, reflect.Int32, reflect.Int64, reflect.Int16, reflect.Int8:
97	{
98	switch vy.Kind() {
99	case reflect.Int, reflect.Int32, reflect.Int64, reflect.Int16, reflect.Int8:
100	return vx.Int() * vy.Int()
101	case reflect.Float32, reflect.Float64:
102	return float64(vx.Int()) * vy.Float()
103	}
104	}
105	case reflect.Float32, reflect.Float64:
106	{
107	switch vy.Kind() {
108	case reflect.Int, reflect.Int32, reflect.Int64, reflect.Int16, reflect.Int8:
109	return vx.Float() * float64(vy.Int())
110	case reflect.Float32, reflect.Float64:
111	return vx.Float() * vy.Float()
112	}
113	}
114	}
115
116	return "<nil>"
117	}
118
119	func runtime_quo(x, y interface{}) interface{} {
120	vx, vy := reflect.ValueOf(x), reflect.ValueOf(y)
121	switch vx.Kind() {
122	case reflect.Int, reflect.Int32, reflect.Int64, reflect.Int16, reflect.Int8:
123	{
124	switch vy.Kind() {
125	case reflect.Int, reflect.Int32, reflect.Int64, reflect.Int16, reflect.Int8:
126	return vx.Int() / vy.Int()
127	case reflect.Float32, reflect.Float64:
128	return float64(vx.Int()) / vy.Float()
129	}
130	}
131	case reflect.Float32, reflect.Float64:
132	{
133	switch vy.Kind() {
134	case reflect.Int, reflect.Int32, reflect.Int64, reflect.Int16, reflect.Int8:
135	return vx.Float() / float64(vy.Int())
136	case reflect.Float32, reflect.Float64:
137	return vx.Float() / vy.Float()
138	}
139	}
140	}
141
142	return "<nil>"
143	}
144
145	func runtime_rem(x, y interface{}) interface{} {
146	vx, vy := reflect.ValueOf(x), reflect.ValueOf(y)
147	switch vx.Kind() {
148	case reflect.Int, reflect.Int32, reflect.Int64, reflect.Int16, reflect.Int8:
149	{
150	switch vy.Kind() {
151	case reflect.Int, reflect.Int32, reflect.Int64, reflect.Int16, reflect.Int8:
152	return vx.Int() % vy.Int()
153	}
154	}
155	}
156
157	return "<nil>"
158	}
159
160	func runtime_minus(x interface{}) interface{} {
161	vx := reflect.ValueOf(x)
162	switch vx.Kind() {
163	case reflect.Int, reflect.Int32, reflect.Int64, reflect.Int16, reflect.Int8:
164	return -vx.Int()
165	case reflect.Float32, reflect.Float64:
166	return -vx.Float()
167	}
168
169	return "<nil>"
170	}
171
172	func runtime_plus(x interface{}) interface{} {
173	vx := reflect.ValueOf(x)
174	switch vx.Kind() {
175	case reflect.Int, reflect.Int32, reflect.Int64, reflect.Int16, reflect.Int8:
176	return +vx.Int()
177	case reflect.Float32, reflect.Float64:
178	return +vx.Float()
179	}
180
181	return "<nil>"
182	}
183
184	func runtime_eql(x, y interface{}) bool {
185	vx, vy := reflect.ValueOf(x), reflect.ValueOf(y)
186	switch vx.Kind() {
187	case reflect.Int, reflect.Int32, reflect.Int64, reflect.Int16, reflect.Int8:
188	{
189	switch vy.Kind() {
190	case reflect.Int, reflect.Int32, reflect.Int64, reflect.Int16, reflect.Int8:
191	return vx.Int() == vy.Int()
192	case reflect.Float32, reflect.Float64:
193	return float64(vx.Int()) == vy.Float()
194	case reflect.String:
195	return fmt.Sprintf("%d", vx.Int()) == vy.String()
196	}
197	}
198	case reflect.Float32, reflect.Float64:
199	{
200	switch vy.Kind() {
201	case reflect.Int, reflect.Int32, reflect.Int64, reflect.Int16, reflect.Int8:
202	return vx.Float() == float64(vy.Int())
203	case reflect.Float32, reflect.Float64:
204	return vx.Float() == vy.Float()
205	case reflect.String:
206	return fmt.Sprintf("%f", vx.Float()) == vy.String()
207	}
208	}
209	case reflect.String:
210	{
211	switch vy.Kind() {
212	case reflect.Int, reflect.Int32, reflect.Int64, reflect.Int16, reflect.Int8:
213	return vx.String() == fmt.Sprintf("%d", vy.Int())
214	case reflect.Float32, reflect.Float64:
215	return vx.String() == fmt.Sprintf("%f", vy.Float())
216	case reflect.String:
217	return vx.String() == fmt.Sprintf("%s", vy.String())
218	}
219	}
220	case reflect.Bool:
221	{
222	switch vy.Kind() {
223	case reflect.Int, reflect.Int32, reflect.Int64, reflect.Int16, reflect.Int8:
224	return vx.Bool() && vy.Int() != 0
225	case reflect.Bool:
226	return vx.Bool() == vy.Bool()
227	}
228	}
229	}
230
231	return false
232	}
233
234	func runtime_lss(x, y interface{}) bool {
235	vx, vy := reflect.ValueOf(x), reflect.ValueOf(y)
236	switch vx.Kind() {
237	case reflect.Int, reflect.Int32, reflect.Int64, reflect.Int16, reflect.Int8:
238	{
239	switch vy.Kind() {
240	case reflect.Int, reflect.Int32, reflect.Int64, reflect.Int16, reflect.Int8:
241	return vx.Int() < vy.Int()
242	case reflect.Float32, reflect.Float64:
243	return float64(vx.Int()) < vy.Float()
244	case reflect.String:
245	return fmt.Sprintf("%d", vx.Int()) < vy.String()
246	}
247	}
248	case reflect.Float32, reflect.Float64:
249	{
250	switch vy.Kind() {
251	case reflect.Int, reflect.Int32, reflect.Int64, reflect.Int16, reflect.Int8:
252	return vx.Float() < float64(vy.Int())
253	case reflect.Float32, reflect.Float64:
254	return vx.Float() < vy.Float()
255	case reflect.String:
256	return fmt.Sprintf("%f", vx.Float()) < vy.String()
257	}
258	}
259	case reflect.String:
260	{
261	switch vy.Kind() {
262	case reflect.Int, reflect.Int32, reflect.Int64, reflect.Int16, reflect.Int8:
263	return vx.String() < fmt.Sprintf("%d", vy.Int())
264	case reflect.Float32, reflect.Float64:
265	return vx.String() < fmt.Sprintf("%f", vy.Float())
266	case reflect.String:
267	return vx.String() < vy.String()
268	}
269	}
270	}
271
272	return false
273	}
274
275	func runtime_gtr(x, y interface{}) bool {
276	return !runtime_lss(x, y) && !runtime_eql(x, y)
277	}
278
279	func runtime_json(x interface{}) (res string, err error) {
280	bres, err := json.Marshal(x)
281	res = string(bres)
282	return
283	}
284
285	func runtime_unescaped(x string) interface{} {
286	return template.HTML(x)
287	}