Xiangqi.xs

filter: Statementstmt 98.5% 137 / 139 Branchbran 62.0% 36 / 58 Conditioncond n/a MC/DCmcdc n/a Subroutinesub n/a Podpod n/a totaltotal 87.8% 173 / 197 CC 0 SCAR 0
CC
0
Cov
0%
CRAP 0
« xq_engine.c ↑ Summary xq_judge.c »
1 /* Xiangqi.xs - the door to the C board.
2 *
3 * At the TOP of the distribution and not under lib/, because an XSMULTI build's
4 * export list and Strawberry's import library rule never agree on a name. The
5 * siblings that learned this the hard way say so in Go.xs and Balls.xs.
6 *
7 * The XSUBs land in Game::Xiangqi::Engine, not in Game::Xiangqi, and are named
8 * with a leading underscore: they take a raw pointer as a UV and there is no
9 * typemap. The Perl that owns the lifetime is lib/Game/Xiangqi/Engine.pm.
10 *
11 * PHASE 02 SCOPE. This door reaches the board only. `_put` and `_lift` are the
12 * structure primitives from xq_abi.h and CHECK NOTHING: they exist so
13 * t/01-board.t can build a position by hand. Generation, legality, check and
14 * mate are phases 03 and 04 and they append to the table rather than changing
15 * it.
16 */
17  
18 #define PERL_NO_GET_CONTEXT
19  
20 #include "EXTERN.h"
21 #include "perl.h"
22 #include "XSUB.h"
23  
24 #include "xq_abi.h"
25  
26 static const struct xq_abi *XQ = NULL;
27  
28 #define BOARD(u) INT2PTR(struct xq_board *, (u))
29  
30 /* A 64-bit value crosses as a 16-character hex string, never as a UV.
31 *
32 * On a perl with 32-bit IVs a UV cannot hold it and the top half would vanish
33 * silently, which for a zobrist key means a test that passes while comparing
34 * half a number. Hand-rolled rather than via my_snprintf, which takes a length
35 * argument that shadows a local called len in a way that has bitten the house
36 * before. Copied from Go.xs, which is where it was worked out.
37 */
38 272 static SV *xq_hex64(pTHX_ unsigned long long v)
39 {
40 static const char digits[] = "0123456789abcdef";
41 char buf[16];
42 int i;
43 4624 ▶ for (i = 15; i >= 0; i--) {
Branch: 1 branch
BranchTrueFalseTotal
for (i = 15; i >= 0; i--) { 4352 272 4624
44 4352 buf[i] = digits[v & 0xfULL];
45 4352 v >>= 4;
46 }
47 272 return newSVpvn(buf, 16);
48 }
49  
50 MODULE = Game::Xiangqi PACKAGE = Game::Xiangqi::Engine
51  
52 PROTOTYPES: DISABLE
53  
54 BOOT:
55 24 XQ = xq_abi_table();
56  
57 UV
58 _abi_ptr()
59 CODE:
60 0 ▶ RETVAL = PTR2UV(XQ);
Branch: 1 branch
BranchTrueFalseTotal
RETVAL = PTR2UV(XQ); 0 0 0
61 OUTPUT:
62 RETVAL
63  
64 UV
65 _abi_version()
66 CODE:
67 1 ▶ RETVAL = (UV)XQ->abi_version;
Branch: 1 branch
BranchTrueFalseTotal
RETVAL = (UV)XQ->abi_version; 0 1 1
68 OUTPUT:
69 RETVAL
70  
71 UV
72 _new_board()
73 CODE:
74 184 ▶ RETVAL = PTR2UV((XQ->board_new)());
Branch: 1 branch
BranchTrueFalseTotal
RETVAL = PTR2UV((XQ->board_new)()); 162 22 184
75 OUTPUT:
76 RETVAL
77  
78 UV
79 _new_empty()
80 CODE:
81 152 ▶ RETVAL = PTR2UV((XQ->board_empty)());
Branch: 1 branch
BranchTrueFalseTotal
RETVAL = PTR2UV((XQ->board_empty)()); 137 15 152
82 OUTPUT:
83 RETVAL
84  
85 UV
86 _copy_board(u)
87 UV u
88 CODE:
89 236 ▶ RETVAL = PTR2UV((XQ->board_copy)(BOARD(u)));
Branch: 1 branch
BranchTrueFalseTotal
RETVAL = PTR2UV((XQ->board_copy)(BOARD(u))); 222 14 236
90 OUTPUT:
91 RETVAL
92  
93 void
94 _drop_board(u)
95 UV u
96 CODE:
97 628 (XQ->board_drop)(BOARD(u));
98  
99 # A FEN that will not parse returns undef and sets the code in the second
100 # element, rather than croaking: the reason is what a caller shows a person, and
101 # six of them are distinguishable.
102 void
103 _of_fen(fen)
104 const char *fen
105 PREINIT:
106 struct xq_board *b;
107 69 int err = 0;
108 PPCODE:
109 69 b = (XQ->board_of_fen)(fen, &err);
110 69 ▶ EXTEND(SP, 2);
Branch: 1 branch
BranchTrueFalseTotal
EXTEND(SP, 2); 0 69 69
111 69 ▶ if (b) PUSHs(sv_2mortal(newSVuv(PTR2UV(b))));
Branch: 1 branch
BranchTrueFalseTotal
if (b) PUSHs(sv_2mortal(newSVuv(PTR2UV(b)))); 56 13 69
112 13 else PUSHs(&PL_sv_undef);
113 69 PUSHs(sv_2mortal(newSViv(err)));
114  
115 SV *
116 _to_fen(u)
117 UV u
118 PREINIT:
119 char buf[XQ_FEN_MAX];
120 int n;
121 CODE:
122 39 n = (XQ->to_fen)(BOARD(u), buf, (int)sizeof(buf));
123 39 ▶ if (n < 0) XSRETURN_UNDEF;
Branch: 1 branch
BranchTrueFalseTotal
if (n < 0) XSRETURN_UNDEF; 0 39 39
124 39 RETVAL = newSVpvn(buf, (STRLEN)n);
125 OUTPUT:
126 RETVAL
127  
128 int
129 _at(u, pt)
130 UV u
131 int pt
132 CODE:
133 25196 RETVAL = (XQ->at)(BOARD(u), pt);
134 OUTPUT:
135 RETVAL
136  
137 void
138 _put(u, pt, piece)
139 UV u
140 int pt
141 int piece
142 CODE:
143 563 (XQ->put)(BOARD(u), pt, piece);
144  
145 void
146 _lift(u, pt)
147 UV u
148 int pt
149 CODE:
150 2 (XQ->lift)(BOARD(u), pt);
151  
152 int
153 _side(u)
154 UV u
155 CODE:
156 824 RETVAL = (XQ->side)(BOARD(u));
157 OUTPUT:
158 RETVAL
159  
160 void
161 _set_side(u, colour)
162 UV u
163 int colour
164 CODE:
165 66 (XQ->set_side)(BOARD(u), colour);
166  
167 int
168 _count(u, piece)
169 UV u
170 int piece
171 CODE:
172 6 RETVAL = (XQ->count)(BOARD(u), piece);
173 OUTPUT:
174 RETVAL
175  
176 int
177 _find(u, piece)
178 UV u
179 int piece
180 CODE:
181 446 RETVAL = (XQ->find)(BOARD(u), piece);
182 OUTPUT:
183 RETVAL
184  
185 int
186 _move_make(from, to)
187 int from
188 int to
189 CODE:
190 460 RETVAL = (XQ->move_make)(from, to);
191 OUTPUT:
192 RETVAL
193  
194 int
195 _move_from(mv)
196 int mv
197 CODE:
198 7436 RETVAL = (XQ->move_from)(mv);
199 OUTPUT:
200 RETVAL
201  
202 int
203 _move_to(mv)
204 int mv
205 CODE:
206 4319 RETVAL = (XQ->move_to)(mv);
207 OUTPUT:
208 RETVAL
209  
210 # The undo crosses as a STRING OF RAW BYTES and not as a pointer, so nothing is
211 # allocated and nothing can leak when a caller forgets to undo. The header calls
212 # struct xq_undo a value type; an SV of its bytes is exactly that. Returns
213 # (captured, undo).
214 void
215 _do_move(u, mv)
216 UV u
217 int mv
218 PREINIT:
219 struct xq_undo undo;
220 int captured;
221 PPCODE:
222 85351 captured = (XQ->do_move)(BOARD(u), mv, &undo);
223 85351 ▶ EXTEND(SP, 2);
Branch: 1 branch
BranchTrueFalseTotal
EXTEND(SP, 2); 0 85351 85351
224 85351 PUSHs(sv_2mortal(newSViv(captured)));
225 85351 PUSHs(sv_2mortal(newSVpvn((char *)&undo, sizeof(undo))));
226  
227 void
228 _undo_move(u, sv)
229 UV u
230 SV *sv
231 PREINIT:
232 struct xq_undo undo;
233 STRLEN len;
234 const char *p;
235 CODE:
236 84217 p = SvPV(sv, len);
237 84217 ▶ if (len != sizeof(undo))
Branch: 1 branch
BranchTrueFalseTotal
if (len != sizeof(undo)) 0 84217 84217
238 0 croak("Game::Xiangqi::Engine: undo token is %d bytes, wanted %d",
239 (int)len, (int)sizeof(undo));
240 84217 Copy(p, &undo, 1, struct xq_undo);
241 84217 (XQ->undo_move)(BOARD(u), &undo);
242  
243 SV *
244 _key_hex(u)
245 UV u
246 CODE:
247 266 RETVAL = xq_hex64(aTHX_ (XQ->key)(BOARD(u)));
248 OUTPUT:
249 RETVAL
250  
251 SV *
252 _zobrist_hex(piece, pt)
253 int piece
254 int pt
255 CODE:
256 6 RETVAL = xq_hex64(aTHX_ (XQ->zobrist)(piece, pt));
257 OUTPUT:
258 RETVAL
259  
260 int
261 _point_of(file, rank)
262 int file
263 int rank
264 CODE:
265 34065 RETVAL = (XQ->point_of)(file, rank);
266 OUTPUT:
267 RETVAL
268  
269 int
270 _file_of(pt)
271 int pt
272 CODE:
273 4195 RETVAL = (XQ->file_of)(pt);
274 OUTPUT:
275 RETVAL
276  
277 int
278 _rank_of(pt)
279 int pt
280 CODE:
281 8462 RETVAL = (XQ->rank_of)(pt);
282 OUTPUT:
283 RETVAL
284  
285 int
286 _on_board(pt)
287 int pt
288 CODE:
289 3244 RETVAL = (XQ->on_board)(pt);
290 OUTPUT:
291 RETVAL
292  
293 int
294 _in_palace(pt, colour)
295 int pt
296 int colour
297 CODE:
298 282 RETVAL = (XQ->in_palace)(pt, colour);
299 OUTPUT:
300 RETVAL
301  
302 int
303 _crossed_river(pt, colour)
304 int pt
305 int colour
306 CODE:
307 326 RETVAL = (XQ->crossed_river)(pt, colour);
308 OUTPUT:
309 RETVAL
310  
311 int
312 _stride()
313 CODE:
314 3 RETVAL = (XQ->stride)();
315 OUTPUT:
316 RETVAL
317  
318 # ---- phase 03: generation, the attack walk, and perft -----------------------
319  
320 int
321 _horse_leg(u, from, to)
322 UV u
323 int from
324 int to
325 CODE:
326 5 RETVAL = (XQ->horse_leg)(BOARD(u), from, to);
327 OUTPUT:
328 RETVAL
329  
330 int
331 _elephant_eye(u, from, to)
332 UV u
333 int from
334 int to
335 CODE:
336 2 RETVAL = (XQ->elephant_eye)(BOARD(u), from, to);
337 OUTPUT:
338 RETVAL
339  
340 int
341 _cannon_screens(u, from, to)
342 UV u
343 int from
344 int to
345 CODE:
346 7 RETVAL = (XQ->cannon_screens)(BOARD(u), from, to);
347 OUTPUT:
348 RETVAL
349  
350 int
351 _soldier_may(u, from, to)
352 UV u
353 int from
354 int to
355 CODE:
356 3 RETVAL = (XQ->soldier_may)(BOARD(u), from, to);
357 OUTPUT:
358 RETVAL
359  
360 int
361 _generals_face(u)
362 UV u
363 CODE:
364 10 RETVAL = (XQ->generals_face)(BOARD(u));
365 OUTPUT:
366 RETVAL
367  
368 int
369 _attacked(u, pt, by)
370 UV u
371 int pt
372 int by
373 CODE:
374 318 RETVAL = (XQ->attacked)(BOARD(u), pt, by);
375 OUTPUT:
376 RETVAL
377  
378 int
379 _in_check(u, colour)
380 UV u
381 int colour
382 CODE:
383 255 RETVAL = (XQ->in_check)(BOARD(u), colour);
384 OUTPUT:
385 RETVAL
386  
387 void
388 _gen_moves(u)
389 UV u
390 PREINIT:
391 int buf[XQ_MAX_MOVES];
392 int n, i;
393 PPCODE:
394 58 n = (XQ->gen_moves)(BOARD(u), buf);
395 58 ▶ EXTEND(SP, n);
Branch: 2 branches
BranchTrueFalseTotal
EXTEND(SP, n); 58 0 58
EXTEND(SP, n); 0 58 58
396 1191 ▶ for (i = 0; i < n; i++) PUSHs(sv_2mortal(newSViv(buf[i])));
Branch: 1 branch
BranchTrueFalseTotal
for (i = 0; i < n; i++) PUSHs(sv_2mortal(newSViv(buf[i]))); 1133 58 1191
397  
398 void
399 _gen_legal(u)
400 UV u
401 PREINIT:
402 int buf[XQ_MAX_MOVES];
403 int n, i;
404 PPCODE:
405 6531 n = (XQ->gen_legal)(BOARD(u), buf);
406 6531 ▶ EXTEND(SP, n);
Branch: 2 branches
BranchTrueFalseTotal
EXTEND(SP, n); 6531 0 6531
EXTEND(SP, n); 0 6531 6531
407 193421 ▶ for (i = 0; i < n; i++) PUSHs(sv_2mortal(newSViv(buf[i])));
Branch: 1 branch
BranchTrueFalseTotal
for (i = 0; i < n; i++) PUSHs(sv_2mortal(newSViv(buf[i]))); 186890 6531 193421
408  
409 # The four counters come back as strings, for the reason the key does: depth 6
410 # is 5,392,831,844 nodes and a 32-bit IV would quietly keep the low half.
411 void
412 _perft(u, depth)
413 UV u
414 int depth
415 PREINIT:
416 struct xq_perft p;
417 char buf[24];
418 PPCODE:
419 54 (XQ->perft)(BOARD(u), depth, &p);
420 54 ▶ EXTEND(SP, 4);
Branch: 1 branch
BranchTrueFalseTotal
EXTEND(SP, 4); 0 54 54
421 #define PUSH_U64(v) \
422 do { int n_ = sprintf(buf, "%.0f", (double)(v)); \
423 PUSHs(sv_2mortal(newSVpvn(buf, n_))); } while (0)
424 54 PUSH_U64(p.nodes);
425 54 PUSH_U64(p.checks);
426 54 PUSH_U64(p.captures);
427 54 PUSH_U64(p.mates);
428 #undef PUSH_U64
429  
430 # ---- phase 04: the endings and the mate search ------------------------------
431  
432 # Returns (winner_colour, reason). winner is 0 while the game is on. BOTH
433 # reasons are a win for the side not to move: a stalemate is a loss in this game.
434 void
435 _outcome(u)
436 UV u
437 PREINIT:
438 81965 int reason = 0;
439 int winner;
440 PPCODE:
441 81965 winner = (XQ->outcome)(BOARD(u), &reason);
442 81965 ▶ EXTEND(SP, 2);
Branch: 1 branch
BranchTrueFalseTotal
EXTEND(SP, 2); 0 81965 81965
443 81965 PUSHs(sv_2mortal(newSViv(winner)));
444 81965 PUSHs(sv_2mortal(newSViv(reason)));
445  
446 int
447 _mate_in(u, plies)
448 UV u
449 int plies
450 CODE:
451 108 RETVAL = (XQ->mate_in)(BOARD(u), plies);
452 OUTPUT:
453 RETVAL
454  
455 # ---- phase 05: the vocabulary of the Asian Rules ----------------------------
456  
457 int
458 _is_check(u, mv)
459 UV u
460 int mv
461 CODE:
462 106 RETVAL = (XQ->is_check)(BOARD(u), mv);
463 OUTPUT:
464 RETVAL
465  
466 int
467 _is_mate(u, mv)
468 UV u
469 int mv
470 CODE:
471 57 RETVAL = (XQ->is_mate)(BOARD(u), mv);
472 OUTPUT:
473 RETVAL
474  
475 int
476 _is_ttc(u, mv)
477 UV u
478 int mv
479 CODE:
480 105 RETVAL = (XQ->is_ttc)(BOARD(u), mv);
481 OUTPUT:
482 RETVAL
483  
484 # returns (is_chase, victim_point)
485 void
486 _is_chase(u, mv)
487 UV u
488 int mv
489 PREINIT:
490 96 int victim = 0, r;
491 PPCODE:
492 96 r = (XQ->is_chase)(BOARD(u), mv, &victim);
493 96 ▶ EXTEND(SP, 2);
Branch: 1 branch
BranchTrueFalseTotal
EXTEND(SP, 2); 0 96 96
494 96 PUSHs(sv_2mortal(newSViv(r)));
495 96 PUSHs(sv_2mortal(newSViv(victim)));
496  
497 int
498 _is_exchange(u, mv)
499 UV u
500 int mv
501 CODE:
502 138 RETVAL = (XQ->is_exchange)(BOARD(u), mv);
503 OUTPUT:
504 RETVAL
505  
506 int
507 _is_block(u, mv)
508 UV u
509 int mv
510 CODE:
511 85 RETVAL = (XQ->is_block)(BOARD(u), mv);
512 OUTPUT:
513 RETVAL
514  
515 int
516 _is_sacrifice(u, mv)
517 UV u
518 int mv
519 CODE:
520 89 RETVAL = (XQ->is_sacrifice)(BOARD(u), mv);
521 OUTPUT:
522 RETVAL
523  
524 int
525 _is_idle(u, mv)
526 UV u
527 int mv
528 CODE:
529 143 RETVAL = (XQ->is_idle)(BOARD(u), mv);
530 OUTPUT:
531 RETVAL
532  
533 # returns (protected, real)
534 void
535 _protected_at(u, pt)
536 UV u
537 int pt
538 PREINIT:
539 97 int real = 0, r;
540 PPCODE:
541 97 r = (XQ->protected_at)(BOARD(u), pt, &real);
542 97 ▶ EXTEND(SP, 2);
Branch: 1 branch
BranchTrueFalseTotal
EXTEND(SP, 2); 0 97 97
543 97 PUSHs(sv_2mortal(newSViv(r)));
544 97 PUSHs(sv_2mortal(newSViv(real)));
545  
546 int
547 _value_of(piece)
548 int piece
549 CODE:
550 4 RETVAL = (XQ->value_of)(piece);
551 OUTPUT:
552 RETVAL
553  
554 # ---- phase 06: the judge -----------------------------------------------------
555  
556 # Takes the move list as an array ref of packed moves and returns a flat list of
557 # key/value pairs, which the Perl side turns into a hash. A struct with eleven
558 # fields is not worth a typemap for one caller.
559 void
560 _judge(u, av)
561 UV u
562 AV *av
563 PREINIT:
564 struct xq_verdict v;
565 int moves[XQ_MAX_PLIES];
566 int n, i;
567 PPCODE:
568 283 n = av_len(av) + 1;
569 283 ▶ if (n > XQ_MAX_PLIES) n = XQ_MAX_PLIES;
Branch: 1 branch
BranchTrueFalseTotal
if (n > XQ_MAX_PLIES) n = XQ_MAX_PLIES; 0 283 283
570 2920 ▶ for (i = 0; i < n; i++) {
Branch: 1 branch
BranchTrueFalseTotal
for (i = 0; i < n; i++) { 2637 283 2920
571 2637 SV **e = av_fetch(av, i, 0);
572 2637 ▶ moves[i] = e ? (int) SvIV(*e) : 0;
Branch: 1 branch
BranchTrueFalseTotal
moves[i] = e ? (int) SvIV(*e) : 0; 2637 0 2637
573 }
574 283 (XQ->judge)(BOARD(u), moves, n, &v);
575 283 ▶ EXTEND(SP, 22);
Branch: 1 branch
BranchTrueFalseTotal
EXTEND(SP, 22); 0 283 283
576 #define PAIR(k, val) \
577 do { PUSHs(sv_2mortal(newSVpv(k, 0))); \
578 PUSHs(sv_2mortal(newSViv(val))); } while (0)
579 283 PAIR("winner", v.winner);
580 283 PAIR("reason", v.reason);
581 283 PAIR("rule", v.rule);
582 283 PAIR("loop_from", v.loop_from);
583 283 PAIR("loop_len", v.loop_len);
584 283 PAIR("red", v.behaviour[0]);
585 283 PAIR("black", v.behaviour[1]);
586 283 PAIR("red_run", v.run[0]);
587 283 PAIR("black_run", v.run[1]);
588 283 PAIR("effective", v.effective);
589 283 PAIR("progress", v.progress);
590 #undef PAIR
591  
592 int
593 _rule_count()
594 CODE:
595 8 RETVAL = (XQ->rule_count)();
596 OUTPUT:
597 RETVAL
598  
599 void
600 _rule_at(i)
601 int i
602 PREINIT:
603 const struct xq_chase_rule *r;
604 PPCODE:
605 176 r = (XQ->rule_at)(i);
606 176 ▶ if (!r) XSRETURN_EMPTY;
Branch: 1 branch
BranchTrueFalseTotal
if (!r) XSRETURN_EMPTY; 0 176 176
607 176 ▶ EXTEND(SP, 8);
Branch: 1 branch
BranchTrueFalseTotal
EXTEND(SP, 8); 0 176 176
608 176 PUSHs(sv_2mortal(newSViv(r->number)));
609 176 PUSHs(sv_2mortal(newSViv(r->chaser)));
610 176 PUSHs(sv_2mortal(newSViv(r->victim)));
611 176 PUSHs(sv_2mortal(newSViv(r->protectedness)));
612 176 PUSHs(sv_2mortal(newSViv(r->chasers)));
613 176 PUSHs(sv_2mortal(newSViv(r->victims)));
614 176 PUSHs(sv_2mortal(newSViv(r->verdict)));
615 176 PUSHs(sv_2mortal(newSVpv(r->text, 0)));
616  
617 # ---- phase 09: the search ----------------------------------------------------
618  
619 int
620 _evaluate(u)
621 UV u
622 CODE:
623 51 RETVAL = (XQ->evaluate)(BOARD(u));
624 OUTPUT:
625 RETVAL
626  
627 # returns (move, nodes, depth, score, stopped). nodes as a string: a budget of
628 # billions is legal and a 32-bit IV would keep the low half.
629 void
630 _search(u, budget, seed)
631 UV u
632 double budget
633 UV seed
634 PREINIT:
635 struct xq_search_info info;
636 char buf[24];
637 int mv, n;
638 PPCODE:
639 521 mv = (XQ->search_best)(BOARD(u), (unsigned long long) budget,
640 (unsigned int) seed, &info);
641 521 ▶ EXTEND(SP, 5);
Branch: 1 branch
BranchTrueFalseTotal
EXTEND(SP, 5); 0 521 521
642 521 PUSHs(sv_2mortal(newSViv(mv)));
643 521 n = sprintf(buf, "%.0f", (double) info.nodes);
644 521 PUSHs(sv_2mortal(newSVpvn(buf, n)));
645 521 PUSHs(sv_2mortal(newSViv(info.depth)));
646 521 PUSHs(sv_2mortal(newSViv(info.score)));
647 521 PUSHs(sv_2mortal(newSViv(info.stopped)));
648  
649 void
650 _search_to_depth(u, max_depth, budget, seed)
651 UV u
652 int max_depth
653 double budget
654 UV seed
655 PREINIT:
656 struct xq_search_info info;
657 char buf[24];
658 int mv, n;
659 PPCODE:
660 6 mv = (XQ->search_to_depth)(BOARD(u), max_depth,
661 (unsigned long long) budget,
662 (unsigned int) seed, &info);
663 6 ▶ EXTEND(SP, 5);
Branch: 1 branch
BranchTrueFalseTotal
EXTEND(SP, 5); 0 6 6
664 6 PUSHs(sv_2mortal(newSViv(mv)));
665 6 n = sprintf(buf, "%.0f", (double) info.nodes);
666 6 PUSHs(sv_2mortal(newSVpvn(buf, n)));
667 6 PUSHs(sv_2mortal(newSViv(info.depth)));
668 6 PUSHs(sv_2mortal(newSViv(info.score)));
669 6 PUSHs(sv_2mortal(newSViv(info.stopped)));
« xq_engine.c ↑ Summary xq_judge.c »