Debian Codegraph @

ext/uvector/uvgen.scm

raw
1 ;;
2 ;; Generates uvector.c, uvector.h and uvlib.scm the corresponding *.tmpl file
3 ;;
4
5 (use srfi.13)
6 (use text.tree)
7 (use file.util)
8 (use gauche.sequence)
9 (use gauche.parseopt)
10
11 (define p print)
12
13 ;; overwritten by template files
14 (define *tmpl-prologue* '())
15 (define *tmpl-body* '())
16 (define *tmpl-epilogue* '())
17 (define *extra-procedure* #f)
18
19 ;; entry
20 (define (main args)
21 (if (or (null? (cdr args))
22 (not (string-suffix? ".tmpl" (cadr args))))
23 (exit 0 "Usage: gosh uvgen.scm <file>.tmpl")
24 (let ([ifile (cadr args)]
25 [rules (make-rules)])
26 (process ifile rules)))
27 0)
28
29 ;; file translation toplevel
30 (define (process tmpl-file rules)
31 ;; we take basename, for the input file may be prefixed by $srcdir.
32 (let1 c-file (sys-basename (regexp-replace #/\.tmpl$/ tmpl-file ""))
33 (load-template tmpl-file)
34 (with-output-to-file c-file
35 (^[]
36 (for-each print *tmpl-prologue*)
37 (dolist [rule rules]
38 (for-each (cut substitute <> rule) *tmpl-body*))
39 (when *extra-procedure*
40 (*extra-procedure*))
41 (for-each print *tmpl-epilogue*)))))
42
43 ;; load uvect.tmpl
44 ;; this sets up variables.
45 (define (load-template tmpl-file)
46 (define (translate)
47 (let loop ([line (read-line)])
48 (cond [(eof-object? line)]
49 [(string-prefix? "///" line)
50 (p (string-drop line 3))
51 (loop (read-line))]
52 [else
53 (p "\"" (regexp-replace-all #/[\\\"]/ line "\\\\\\0") "\"")
54 (loop (read-line))])))
55
56 (call-with-temporary-file
57 (^[out name]
58 (with-output-to-port out
59 (cut with-input-from-file tmpl-file
60 (cut translate)))
61 (close-output-port out)
62 (call-with-input-file name load-from-port))
63 :prefix (sys-basename tmpl-file)))
64
65 (define (getval rules key)
66 (cond [(assq key rules) => cadr] [else #f]))
67
68 ;; substitute ${param arg ...} in LINE. output goes to curout.
69 ;; rules :: ((<string> <string-or-proc>) ...)
70 (define (substitute line rules)
71 (define (sub key . args)
72 (cond [(any (cut getval rules <>) (cons key (compatible-keys key)))
73 => (^v (if (string? v)
74 (display v)
75 (display (apply v args))))]
76 [else (error "unknown substitution word:" key)]))
77 (with-input-from-string line
78 (^[] (let loop ([ch (read-char)])
79 (cond [(eof-object? ch) (newline)]
80 [(char=? ch #\$)
81 (read-char) ;; we count on well-formed template
82 (let1 lis (read-list #\})
83 (apply sub lis)
84 (loop (read-char)))]
85 [else
86 (write-char ch)
87 (loop (read-char))])))))
88
89 (define (compatible-keys key)
90 (case key
91 [(ntype) '(etype)]
92 [(NUNBOX) '(UNBOX)]
93 [(VMBOX) '(BOX)]
94 [(NBOX) '(BOX)]
95 [(VMNBOX) '(NBOX BOX)]
96 [else '()]))
97
98 ;; keys ------------------------------------------------------------
99 ;;
100 ;; t : lowercase tag, e.g. "s16"
101 ;; T : uppercase tag, e.g. "S16"
102 ;; etype : element C type, e.g. int16_t for s16vector
103 ;; ntype : natural C type to operate on each element. (optional)
104 ;; e.g. long for s16vector
105 ;; ZERO : 'zero' value of etype (optional)
106 ;; (REF_NTYPE v i)
107 ;; : Reference v[i] as ntype
108 ;; (CAST_N2E exp)
109 ;; : Cast etype's expression exp to ntype (optional)
110 ;; (UNBOX dst src clamp)
111 ;; : etype dst = unbox(ScmObj src, clamp)
112 ;; (NUNBOX dst src clamp)
113 ;; : ntype dst = unbox(ScmObj src, clamp) (optional)
114 ;; (BOX dst src)
115 ;; : ScmObj dst = box(etype src)
116 ;; (NBOX dst src)
117 ;; : ScmObj dst = box(ntype src) (optional)
118 ;; (VMBOX dst src)
119 ;; : ScmObj dst = box(etype src) // dst is VM register (optional)
120 ;; (NVMBOX dst src)
121 ;; : ScmObj dst = box(ntype src) // dst is VM register (optional)
122
123 ;; substitution rules ----------------------------------------------
124
125 (define (make-integer-rules)
126 (list (make-s8rules)
127 (make-u8rules)
128 (make-s16rules)
129 (make-u16rules)
130 (make-s32rules)
131 (make-u32rules)
132 (make-s64rules)
133 (make-u64rules)))
134
135 (define (make-flonum-rules)
136 (list (make-f16rules)
137 (make-f32rules)
138 (make-f64rules)))
139
140 (define (make-complex-rules)
141 (list (make-c32rules)
142 (make-c64rules)
143 (make-c128rules)))
144
145 (define (make-scalar-rules)
146 (append (make-integer-rules) (make-flonum-rules)))
147
148 (define (make-rules)
149 (append (make-integer-rules) (make-flonum-rules) (make-complex-rules)))
150
151 ;; common stuff
152 (define (common-rules tag)
153 (let* ([stag (symbol->string tag)]
154 [STAG (string-upcase stag)])
155 `((t ,stag)
156 (T ,STAG)
157 (CAST_N2E ,identity)
158 (ZERO "0"))))
159
160 (define (make-s8rules)
161 `((etype "int8_t")
162 (ntype "long")
163 (REF_NTYPE ,(^[v i] #"(long)SCM_S8VECTOR_ELEMENTS(~v)[~i]"))
164 (CAST_N2E ,(^[exp] #"(int8_t)(~exp)"))
165 (UNBOX ,(^[dst src clamp]
166 #"~dst = (int8_t)Scm_GetInteger8Clamp(~src, ~clamp, NULL)"))
167 (NUNBOX ,(^[dst src clamp]
168 #"~dst = Scm_GetInteger8Clamp(~src, ~clamp, NULL)"))
169 (BOX ,(^[dst src] #"~dst = SCM_MAKE_INT(~src)"))
170 (NBOX ,(^[dst src] #"~dst = Scm_MakeInteger(~src)"))
171 ,@(common-rules 's8)))
172
173 (define (make-u8rules)
174 `((etype "uint8_t")
175 (ntype "long")
176 (REF_NTYPE ,(^[v i] #"(long)SCM_U8VECTOR_ELEMENTS(~v)[~i]"))
177 (CAST_N2E ,(^[exp] #"(uint8_t)(~exp)"))
178 (UNBOX ,(^[dst src clamp]
179 #"~dst = (uint8_t)Scm_GetIntegerU8Clamp(~src, ~clamp, NULL)"))
180 (NUNBOX ,(^[dst src clamp]
181 #"~dst = Scm_GetIntegerU8Clamp(~src, ~clamp, NULL)"))
182 (BOX ,(^[dst src] #"~dst = SCM_MAKE_INT(~src)"))
183 (NBOX ,(^[dst src] #"~dst = Scm_MakeIntegerU(~src)"))
184 ,@(common-rules 'u8)))
185
186 (define (make-s16rules)
187 `((etype "int16_t")
188 (ntype "long")
189 (REF_NTYPE ,(^[v i] #"(long)SCM_S16VECTOR_ELEMENTS(~v)[~i]"))
190 (CAST_N2E ,(^[exp] #"(int16_t)(~exp)"))
191 (UNBOX ,(^[dst src clamp]
192 #"~dst = (int16_t)Scm_GetInteger16Clamp(~src, ~clamp, NULL)"))
193 (NUNBOX ,(^[dst src clamp]
194 #"~dst = Scm_GetInteger16Clamp(~src, ~clamp, NULL)"))
195 (BOX ,(^[dst src] #"~dst = SCM_MAKE_INT(~src)"))
196 (NBOX ,(^[dst src] #"~dst = Scm_MakeInteger(~src)"))
197 ,@(common-rules 's16)))
198
199 (define (make-u16rules)
200 `((etype "uint16_t")
201 (ntype "long")
202 (REF_NTYPE ,(^[v i] #"(long)SCM_U16VECTOR_ELEMENTS(~v)[~i]"))
203 (CAST_N2E ,(^[exp] #"(uint16_t)(~exp)"))
204 (UNBOX ,(^[dst src clamp]
205 #"~dst = (uint16_t)Scm_GetIntegerU16Clamp(~src, ~clamp, NULL)"))
206 (NUNBOX ,(^[dst src clamp]
207 #"~dst = Scm_GetIntegerU16Clamp(~src, ~clamp, NULL)"))
208 (BOX ,(^[dst src] #"~dst = SCM_MAKE_INT(~src)"))
209 (NBOX ,(^[dst src] #"~dst = Scm_MakeIntegerU(~src)"))
210 ,@(common-rules 'u16)))
211
212 (define (make-s32rules)
213 `((etype "int32_t")
214 (ntype "long")
215 (REF_NTYPE ,(^[v i] #"(long)SCM_S32VECTOR_ELEMENTS(~v)[~i]"))
216 (CAST_N2E ,(^[exp] #"(int32_t)(~exp)"))
217 (UNBOX ,(^[dst src clamp]
218 #"~dst = (int32_t)Scm_GetInteger32Clamp(~src, ~clamp, NULL)"))
219 (NUNBOX ,(^[dst src clamp]
220 #"~dst = Scm_GetInteger32Clamp(~src, ~clamp, NULL)"))
221 (BOX ,(^[dst src] #"~dst = Scm_MakeInteger(~src)"))
222 ,@(common-rules 's32)))
223
224 (define (make-u32rules)
225 `((etype "uint32_t")
226 (ntype "u_long")
227 (REF_NTYPE ,(^[v i] #"(u_long)SCM_U32VECTOR_ELEMENTS(~v)[~i]"))
228 (CAST_N2E ,(^[exp] #"(uint32_t)(~exp)"))
229 (UNBOX ,(^[dst src clamp]
230 #"~dst = (uint32_t)Scm_GetIntegerU32Clamp(~src, ~clamp, NULL)"))
231 (NUNBOX ,(^[dst src clamp]
232 #"~dst = Scm_GetIntegerU32Clamp(~src, ~clamp, NULL)"))
233 (BOX ,(^[dst src] #"~dst = Scm_MakeIntegerU(~src)"))
234 ,@(common-rules 'u32)))
235
236 (define (make-s64rules)
237 `((etype "int64_t")
238 (REF_NTYPE ,(^[v i] #"SCM_S64VECTOR_ELEMENTS(~v)[~i]"))
239 (UNBOX ,(^[dst src clamp]
240 #"~dst = Scm_GetInteger64Clamp(~src, ~clamp, NULL)"))
241 (BOX ,(^[dst src] #"~dst = Scm_MakeInteger64(~src)"))
242 ,@(common-rules 's64)))
243
244 (define (make-u64rules)
245 `((etype "uint64_t")
246 (REF_NTYPE ,(^[v i] #"SCM_U64VECTOR_ELEMENTS(~v)[~i]"))
247 (UNBOX ,(^[dst src clamp]
248 #"~dst = Scm_GetIntegerU64Clamp(~src, ~clamp, NULL)"))
249 (BOX ,(^[dst src] #"~dst = Scm_MakeIntegerU64(~src)"))
250 ,@(common-rules 'u64)))
251
252 (define (make-f16rules)
253 `((etype "ScmHalfFloat")
254 (ntype "double")
255 (REF_NTYPE ,(^[v i] #"Scm_HalfToDouble(SCM_F16VECTOR_ELEMENTS(~v)[~i])"))
256 (CAST_N2E ,(^[exp] #"Scm_DoubleToHalf(~exp)"))
257 (UNBOX ,(^[dst src clamp]
258 #"~dst = Scm_DoubleToHalf(Scm_GetDouble(~src))"))
259 (NUNBOX ,(^[dst src clamp]
260 #"~dst = Scm_GetDouble(~src)"))
261 (BOX ,(^[dst src] #"~dst = Scm_MakeFlonum(Scm_HalfToDouble(~src))"))
262 (VMBOX ,(^[dst src] #"~dst = Scm_VMReturnFlonum(Scm_HalfToDouble(~src))"))
263 (NBOX ,(^[dst src] #"~dst = Scm_MakeFlonum(~src)"))
264 (VMNBOX ,(^[dst src] #"~dst = Scm_VMReturnFlonum(~src)"))
265 ,@(common-rules 'f16)))
266
267 (define (make-f32rules)
268 `((etype "float")
269 (ntype "double")
270 (REF_NTYPE ,(^[v i] #"(double)SCM_F32VECTOR_ELEMENTS(~v)[~i]"))
271 (CAST_N2E ,(^[exp] #"(float)(~exp)"))
272 (UNBOX ,(^[dst src clamp] #"~dst = (float)Scm_GetDouble(~src)"))
273 (NUNBOX ,(^[dst src clamp] #"~dst = Scm_GetDouble(~src)"))
274 (BOX ,(^[dst src] #"~dst = Scm_MakeFlonum((double)~src)"))
275 (VMBOX ,(^[dst src] #"~dst = Scm_VMReturnFlonum((double)~src)"))
276 (NBOX ,(^[dst src] #"~dst = Scm_MakeFlonum(~src)"))
277 (VMNBOX ,(^[dst src] #"~dst = Scm_VMReturnFlonum(~src)"))
278 ,@(common-rules 'f32)))
279
280 (define (make-f64rules)
281 `((etype "double")
282 (REF_NTYPE ,(^[v i] #"SCM_F64VECTOR_ELEMENTS(~v)[~i]"))
283 (UNBOX ,(^[dst src clamp] #"~dst = Scm_GetDouble(~src)"))
284 (BOX ,(^[dst src] #"~dst = Scm_MakeFlonum(~src)"))
285 (VMBOX ,(^[dst src] #"~dst = Scm_VMReturnFlonum(~src)"))
286 ,@(common-rules 'f64)))
287
288 (define (make-c32rules)
289 `((etype "ScmHalfComplex")
290 (REF_NTYPE ,(^[v i] #"SCM_C32VECTOR_ELEMENTS(~v)[~i]"))
291 (UNBOX ,(^[dst src clamp] #"~dst = Scm_GetHalfComplex(~src)"))
292 (BOX ,(^[dst src] #"~dst = Scm_HalfComplexToComplex(~src)"))
293 (ZERO "(ScmHalfComplex){0, 0}")
294 ,@(common-rules 'c32)))
295
296 (define (make-c64rules)
297 `((etype "ScmFloatComplex")
298 (REF_NTYPE ,(^[v i] #"SCM_C64VECTOR_ELEMENTS(~v)[~i]"))
299 (UNBOX ,(^[dst src clamp] #"~dst = Scm_GetFloatComplex(~src)"))
300 (BOX ,(^[dst src] #"~dst = Scm_FloatComplexToComplex(~src)"))
301 ,@(common-rules 'c64)))
302
303 (define (make-c128rules)
304 `((etype "ScmDoubleComplex")
305 (REF_NTYPE ,(^[v i] #"SCM_C128VECTOR_ELEMENTS(~v)[~i]"))
306 (UNBOX ,(^[dst src clamp] #"~dst = Scm_GetDoubleComplex(~src)"))
307 (BOX ,(^[dst src] #"~dst = Scm_DoubleComplexToComplex(~src)"))
308 ,@(common-rules 'c128)))
309
310 (define (dummy . _) "/* not implemented */")
311
312 ;;===============================================================
313 ;; Uvector operation generator
314 ;;
315
316 (define (generate-numop)
317 (for-each (^[opname Opname Sopname]
318 (dolist [rule (make-rules)]
319 (for-each (cute substitute <> `((opname ,opname)
320 (Opname ,Opname)
321 (Sopname ,Sopname)
322 ,@rule))
323 *tmpl-numop*)))
324 '("add" "sub" "mul")
325 '("Add" "Sub" "Mul")
326 '("Add" "Sub" "Mul"))
327 (dolist [rule (append (make-flonum-rules) (make-complex-rules))]
328 (for-each (cute substitute <> `((opname "div")
329 (Opname "Div")
330 (Sopname "Div")
331 ,@rule))
332 *tmpl-numop*)))
333
334 (define (generate-bitop)
335 (dolist [rule (make-integer-rules)]
336 (for-each
337 (^[opname Opname]
338 (define (BITOP r v0 v1)
339 (let ([tag (getval rule 't)]
340 [c-op (case (string->symbol opname)
341 ((and) "&") ((ior) "|") ((xor) "^"))])
342 (if (member tag '("s8" "u8" "s16" "u16" "s32" "u32"))
343 #"~r = ~v0 ~c-op ~v1"
344 #"INT64BITOP(~|r|, ~|v0|, ~|c-op|, ~|v1|)")))
345 (define (BITEXT r v)
346 (let1 tag (getval rule 't)
347 (if (member tag '("s8" "u8" "s16" "u16" "s32" "u32"))
348 #"~r = bitext(~v)"
349 #"~r = bitext64(~v)")))
350 (for-each (cute substitute <> `((opname ,opname)
351 (Opname ,Opname)
352 (BITOP ,BITOP)
353 (BITEXT ,BITEXT)
354 ,@rule))
355 *tmpl-bitop*))
356 '("and" "ior" "xor")
357 '("And" "Ior" "Xor"))))
358
359 (define (generate-dotop)
360 (dolist [rule (make-rules)]
361 (for-each (cute substitute <> rule) *tmpl-dotop*)))
362
363 (define (generate-rangeop)
364 (dolist [rule (make-scalar-rules)]
365 (let ([tag (string->symbol (getval rule 't))]
366 [TAG (getval rule 'T)]
367 [cast (getval rule 'CAST_N2E)])
368 (define (GETLIM r dc v)
369 (let1 getter
370 (case tag
371 [(s8) #"Scm_GetInteger8Clamp(~|v|, SCM_CLAMP_BOTH, NULL)"]
372 [(u8) #"Scm_GetIntegerU8Clamp(~|v|, SCM_CLAMP_BOTH, NULL)"]
373 [(s16) #"Scm_GetInteger16Clamp(~|v|, SCM_CLAMP_BOTH, NULL)"]
374 [(u16) #"Scm_GetIntegerU16Clamp(~|v|, SCM_CLAMP_BOTH, NULL)"]
375 [(s32) #"Scm_GetInteger32Clamp(~|v|, SCM_CLAMP_BOTH, NULL)"]
376 [(u32) #"Scm_GetIntegerU32Clamp(~|v|, SCM_CLAMP_BOTH, NULL)"]
377 [(s64) #"Scm_GetInteger64Clamp(~|v|, SCM_CLAMP_BOTH, NULL)"]
378 [(u64) #"Scm_GetIntegerU64Clamp(~|v|, SCM_CLAMP_BOTH, NULL)"]
379 [(f16 f32 f64) #"Scm_GetDouble(~|v|)"])
380 (tree->string
381 `("if ((",dc" = SCM_FALSEP(",v")) == FALSE) {\n"
382 " ",r" = ",getter";\n"
383 "}"))))
384 (define (LT a b)
385 (case tag
386 [(s64 u64) #"INT64LT(~|a|, ~|b|)"]
387 [else #"(~a < ~b)"]))
388 (dolist [ops `(("range-check" "RangeCheck"
389 ""
390 "return Scm_MakeInteger(i)"
391 "SCM_FALSE")
392 ("clamp" "Clamp"
393 "ScmObj d = Scm_UVectorCopy(SCM_UVECTOR(x), 0, -1)"
394 ,#"SCM_~|TAG|VECTOR_ELEMENTS(d)[i] = ~(cast \"val\")"
395 "d")
396 ("clamp!" "ClampX"
397 ""
398 ,#"SCM_~|TAG|VECTOR_ELEMENTS(x)[i] = ~(cast \"val\")"
399 "SCM_OBJ(x)")
400 )]
401 (for-each (cute substitute <> `((GETLIM ,GETLIM)
402 (LT ,LT)
403 (opname ,(ref ops 0))
404 (Opname ,(ref ops 1))
405 (dstdecl ,(ref ops 2))
406 (action ,(ref ops 3))
407 (okval ,(ref ops 4))
408 ,@rule))
409 *tmpl-rangeop*)))))
410
411 (define (generate-swapb)
412 (dolist [rule (make-scalar-rules)]
413 (let1 tag (string->symbol (getval rule 't))
414 (define (SWAPB)
415 (case tag
416 [(s16 u16 f16) "SWAP_2"]
417 [(s32 u32 f32) "SWAP_4"]
418 [(s64 u64 f64) "SWAP_8"]))
419 (unless (memq tag '(s8 u8))
420 (for-each (cute substitute <> `((SWAPB ,SWAPB) ,@rule))
421 *tmpl-swapb*)))))