ptx_parser/unparser/instruction/setp.rs
1//! Original PTX specification:
2//!
3//! setp.CmpOp{.ftz}.type p{|q}, a, b;
4//! setp.CmpOp.BoolOp{.ftz}.type p{|q}, a, b, {!}c;
5//! .CmpOp = { .eq, .ne, .lt, .le, .gt, .ge, .lo, .ls, .hi, .hs, .equ, .neu, .ltu, .leu, .gtu, .geu, .num, .nan };
6//! .BoolOp = { .and, .or, .xor };
7//! .type = { .b16, .b32, .b64, .u16, .u32, .u64, .s16, .s32, .s64, .f32, .f64 };
8//! --------------------------------------------------------------
9//! setp.CmpOp{.ftz}.f16 p, a, b;
10//! setp.CmpOp.BoolOp{.ftz}.f16 p, a, b, {!}c;
11//! setp.CmpOp{.ftz}.f16x2 p|q, a, b;
12//! setp.CmpOp.BoolOp{.ftz}.f16x2 p|q, a, b, {!}c;
13//! setp.CmpOp.bf16 p, a, b;
14//! setp.CmpOp.BoolOp.bf16 p, a, b, {!}c;
15//! setp.CmpOp.bf16x2 p|q, a, b;
16//! setp.CmpOp.BoolOp.bf16x2 p|q, a, b, {!}c;
17//! .CmpOp = { .eq, .ne, .lt, .le, .gt, .ge, .equ, .neu, .ltu, .leu, .gtu, .geu, .num, .nan };
18//! .BoolOp = { .and, .or, .xor };
19
20#![allow(unused)]
21
22use crate::lexer::PtxToken;
23use crate::unparser::{PtxUnparser, common::*};
24
25pub mod section_0 {
26 use super::*;
27 use crate::r#type::instruction::setp::section_0::*;
28
29 impl PtxUnparser for SetpCmpopFtzType {
30 fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
31 push_opcode(tokens, "setp");
32 match &self.cmpop {
33 Cmpop::Equ => {
34 push_directive(tokens, "equ");
35 }
36 Cmpop::Neu => {
37 push_directive(tokens, "neu");
38 }
39 Cmpop::Ltu => {
40 push_directive(tokens, "ltu");
41 }
42 Cmpop::Leu => {
43 push_directive(tokens, "leu");
44 }
45 Cmpop::Gtu => {
46 push_directive(tokens, "gtu");
47 }
48 Cmpop::Geu => {
49 push_directive(tokens, "geu");
50 }
51 Cmpop::Num => {
52 push_directive(tokens, "num");
53 }
54 Cmpop::Nan => {
55 push_directive(tokens, "nan");
56 }
57 Cmpop::Eq => {
58 push_directive(tokens, "eq");
59 }
60 Cmpop::Ne => {
61 push_directive(tokens, "ne");
62 }
63 Cmpop::Lt => {
64 push_directive(tokens, "lt");
65 }
66 Cmpop::Le => {
67 push_directive(tokens, "le");
68 }
69 Cmpop::Gt => {
70 push_directive(tokens, "gt");
71 }
72 Cmpop::Ge => {
73 push_directive(tokens, "ge");
74 }
75 Cmpop::Lo => {
76 push_directive(tokens, "lo");
77 }
78 Cmpop::Ls => {
79 push_directive(tokens, "ls");
80 }
81 Cmpop::Hi => {
82 push_directive(tokens, "hi");
83 }
84 Cmpop::Hs => {
85 push_directive(tokens, "hs");
86 }
87 }
88 if self.ftz {
89 push_directive(tokens, "ftz");
90 }
91 match &self.type_ {
92 Type::B16 => {
93 push_directive(tokens, "b16");
94 }
95 Type::B32 => {
96 push_directive(tokens, "b32");
97 }
98 Type::B64 => {
99 push_directive(tokens, "b64");
100 }
101 Type::U16 => {
102 push_directive(tokens, "u16");
103 }
104 Type::U32 => {
105 push_directive(tokens, "u32");
106 }
107 Type::U64 => {
108 push_directive(tokens, "u64");
109 }
110 Type::S16 => {
111 push_directive(tokens, "s16");
112 }
113 Type::S32 => {
114 push_directive(tokens, "s32");
115 }
116 Type::S64 => {
117 push_directive(tokens, "s64");
118 }
119 Type::F32 => {
120 push_directive(tokens, "f32");
121 }
122 Type::F64 => {
123 push_directive(tokens, "f64");
124 }
125 }
126 self.p.unparse_tokens(tokens);
127 if let Some(q_0) = self.q.as_ref() {
128 tokens.push(PtxToken::Pipe);
129 q_0.unparse_tokens(tokens);
130 }
131 tokens.push(PtxToken::Comma);
132 self.a.unparse_tokens(tokens);
133 tokens.push(PtxToken::Comma);
134 self.b.unparse_tokens(tokens);
135 tokens.push(PtxToken::Semicolon);
136 }
137 }
138
139 impl PtxUnparser for SetpCmpopBoolopFtzType {
140 fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
141 push_opcode(tokens, "setp");
142 match &self.cmpop {
143 Cmpop::Equ => {
144 push_directive(tokens, "equ");
145 }
146 Cmpop::Neu => {
147 push_directive(tokens, "neu");
148 }
149 Cmpop::Ltu => {
150 push_directive(tokens, "ltu");
151 }
152 Cmpop::Leu => {
153 push_directive(tokens, "leu");
154 }
155 Cmpop::Gtu => {
156 push_directive(tokens, "gtu");
157 }
158 Cmpop::Geu => {
159 push_directive(tokens, "geu");
160 }
161 Cmpop::Num => {
162 push_directive(tokens, "num");
163 }
164 Cmpop::Nan => {
165 push_directive(tokens, "nan");
166 }
167 Cmpop::Eq => {
168 push_directive(tokens, "eq");
169 }
170 Cmpop::Ne => {
171 push_directive(tokens, "ne");
172 }
173 Cmpop::Lt => {
174 push_directive(tokens, "lt");
175 }
176 Cmpop::Le => {
177 push_directive(tokens, "le");
178 }
179 Cmpop::Gt => {
180 push_directive(tokens, "gt");
181 }
182 Cmpop::Ge => {
183 push_directive(tokens, "ge");
184 }
185 Cmpop::Lo => {
186 push_directive(tokens, "lo");
187 }
188 Cmpop::Ls => {
189 push_directive(tokens, "ls");
190 }
191 Cmpop::Hi => {
192 push_directive(tokens, "hi");
193 }
194 Cmpop::Hs => {
195 push_directive(tokens, "hs");
196 }
197 }
198 match &self.boolop {
199 Boolop::And => {
200 push_directive(tokens, "and");
201 }
202 Boolop::Xor => {
203 push_directive(tokens, "xor");
204 }
205 Boolop::Or => {
206 push_directive(tokens, "or");
207 }
208 }
209 if self.ftz {
210 push_directive(tokens, "ftz");
211 }
212 match &self.type_ {
213 Type::B16 => {
214 push_directive(tokens, "b16");
215 }
216 Type::B32 => {
217 push_directive(tokens, "b32");
218 }
219 Type::B64 => {
220 push_directive(tokens, "b64");
221 }
222 Type::U16 => {
223 push_directive(tokens, "u16");
224 }
225 Type::U32 => {
226 push_directive(tokens, "u32");
227 }
228 Type::U64 => {
229 push_directive(tokens, "u64");
230 }
231 Type::S16 => {
232 push_directive(tokens, "s16");
233 }
234 Type::S32 => {
235 push_directive(tokens, "s32");
236 }
237 Type::S64 => {
238 push_directive(tokens, "s64");
239 }
240 Type::F32 => {
241 push_directive(tokens, "f32");
242 }
243 Type::F64 => {
244 push_directive(tokens, "f64");
245 }
246 }
247 self.p.unparse_tokens(tokens);
248 if let Some(q_1) = self.q.as_ref() {
249 tokens.push(PtxToken::Pipe);
250 q_1.unparse_tokens(tokens);
251 }
252 tokens.push(PtxToken::Comma);
253 self.a.unparse_tokens(tokens);
254 tokens.push(PtxToken::Comma);
255 self.b.unparse_tokens(tokens);
256 tokens.push(PtxToken::Comma);
257 if self.c_op { tokens.push(PtxToken::Exclaim); }
258 self.c.unparse_tokens(tokens);
259 tokens.push(PtxToken::Semicolon);
260 }
261 }
262
263}
264
265pub mod section_1 {
266 use super::*;
267 use crate::r#type::instruction::setp::section_1::*;
268
269 impl PtxUnparser for SetpCmpopFtzF16 {
270 fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
271 push_opcode(tokens, "setp");
272 match &self.cmpop {
273 Cmpop::Equ => {
274 push_directive(tokens, "equ");
275 }
276 Cmpop::Neu => {
277 push_directive(tokens, "neu");
278 }
279 Cmpop::Ltu => {
280 push_directive(tokens, "ltu");
281 }
282 Cmpop::Leu => {
283 push_directive(tokens, "leu");
284 }
285 Cmpop::Gtu => {
286 push_directive(tokens, "gtu");
287 }
288 Cmpop::Geu => {
289 push_directive(tokens, "geu");
290 }
291 Cmpop::Num => {
292 push_directive(tokens, "num");
293 }
294 Cmpop::Nan => {
295 push_directive(tokens, "nan");
296 }
297 Cmpop::Eq => {
298 push_directive(tokens, "eq");
299 }
300 Cmpop::Ne => {
301 push_directive(tokens, "ne");
302 }
303 Cmpop::Lt => {
304 push_directive(tokens, "lt");
305 }
306 Cmpop::Le => {
307 push_directive(tokens, "le");
308 }
309 Cmpop::Gt => {
310 push_directive(tokens, "gt");
311 }
312 Cmpop::Ge => {
313 push_directive(tokens, "ge");
314 }
315 }
316 if self.ftz {
317 push_directive(tokens, "ftz");
318 }
319 push_directive(tokens, "f16");
320 self.p.unparse_tokens(tokens);
321 tokens.push(PtxToken::Comma);
322 self.a.unparse_tokens(tokens);
323 tokens.push(PtxToken::Comma);
324 self.b.unparse_tokens(tokens);
325 tokens.push(PtxToken::Semicolon);
326 }
327 }
328
329 impl PtxUnparser for SetpCmpopBoolopFtzF16 {
330 fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
331 push_opcode(tokens, "setp");
332 match &self.cmpop {
333 Cmpop::Equ => {
334 push_directive(tokens, "equ");
335 }
336 Cmpop::Neu => {
337 push_directive(tokens, "neu");
338 }
339 Cmpop::Ltu => {
340 push_directive(tokens, "ltu");
341 }
342 Cmpop::Leu => {
343 push_directive(tokens, "leu");
344 }
345 Cmpop::Gtu => {
346 push_directive(tokens, "gtu");
347 }
348 Cmpop::Geu => {
349 push_directive(tokens, "geu");
350 }
351 Cmpop::Num => {
352 push_directive(tokens, "num");
353 }
354 Cmpop::Nan => {
355 push_directive(tokens, "nan");
356 }
357 Cmpop::Eq => {
358 push_directive(tokens, "eq");
359 }
360 Cmpop::Ne => {
361 push_directive(tokens, "ne");
362 }
363 Cmpop::Lt => {
364 push_directive(tokens, "lt");
365 }
366 Cmpop::Le => {
367 push_directive(tokens, "le");
368 }
369 Cmpop::Gt => {
370 push_directive(tokens, "gt");
371 }
372 Cmpop::Ge => {
373 push_directive(tokens, "ge");
374 }
375 }
376 match &self.boolop {
377 Boolop::And => {
378 push_directive(tokens, "and");
379 }
380 Boolop::Xor => {
381 push_directive(tokens, "xor");
382 }
383 Boolop::Or => {
384 push_directive(tokens, "or");
385 }
386 }
387 if self.ftz {
388 push_directive(tokens, "ftz");
389 }
390 push_directive(tokens, "f16");
391 self.p.unparse_tokens(tokens);
392 tokens.push(PtxToken::Comma);
393 self.a.unparse_tokens(tokens);
394 tokens.push(PtxToken::Comma);
395 self.b.unparse_tokens(tokens);
396 tokens.push(PtxToken::Comma);
397 if self.c_op { tokens.push(PtxToken::Exclaim); }
398 self.c.unparse_tokens(tokens);
399 tokens.push(PtxToken::Semicolon);
400 }
401 }
402
403 impl PtxUnparser for SetpCmpopFtzF16x2 {
404 fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
405 push_opcode(tokens, "setp");
406 match &self.cmpop {
407 Cmpop::Equ => {
408 push_directive(tokens, "equ");
409 }
410 Cmpop::Neu => {
411 push_directive(tokens, "neu");
412 }
413 Cmpop::Ltu => {
414 push_directive(tokens, "ltu");
415 }
416 Cmpop::Leu => {
417 push_directive(tokens, "leu");
418 }
419 Cmpop::Gtu => {
420 push_directive(tokens, "gtu");
421 }
422 Cmpop::Geu => {
423 push_directive(tokens, "geu");
424 }
425 Cmpop::Num => {
426 push_directive(tokens, "num");
427 }
428 Cmpop::Nan => {
429 push_directive(tokens, "nan");
430 }
431 Cmpop::Eq => {
432 push_directive(tokens, "eq");
433 }
434 Cmpop::Ne => {
435 push_directive(tokens, "ne");
436 }
437 Cmpop::Lt => {
438 push_directive(tokens, "lt");
439 }
440 Cmpop::Le => {
441 push_directive(tokens, "le");
442 }
443 Cmpop::Gt => {
444 push_directive(tokens, "gt");
445 }
446 Cmpop::Ge => {
447 push_directive(tokens, "ge");
448 }
449 }
450 if self.ftz {
451 push_directive(tokens, "ftz");
452 }
453 push_directive(tokens, "f16x2");
454 self.p.unparse_tokens(tokens);
455 tokens.push(PtxToken::Pipe);
456 self.q.unparse_tokens(tokens);
457 tokens.push(PtxToken::Comma);
458 self.a.unparse_tokens(tokens);
459 tokens.push(PtxToken::Comma);
460 self.b.unparse_tokens(tokens);
461 tokens.push(PtxToken::Semicolon);
462 }
463 }
464
465 impl PtxUnparser for SetpCmpopBoolopFtzF16x2 {
466 fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
467 push_opcode(tokens, "setp");
468 match &self.cmpop {
469 Cmpop::Equ => {
470 push_directive(tokens, "equ");
471 }
472 Cmpop::Neu => {
473 push_directive(tokens, "neu");
474 }
475 Cmpop::Ltu => {
476 push_directive(tokens, "ltu");
477 }
478 Cmpop::Leu => {
479 push_directive(tokens, "leu");
480 }
481 Cmpop::Gtu => {
482 push_directive(tokens, "gtu");
483 }
484 Cmpop::Geu => {
485 push_directive(tokens, "geu");
486 }
487 Cmpop::Num => {
488 push_directive(tokens, "num");
489 }
490 Cmpop::Nan => {
491 push_directive(tokens, "nan");
492 }
493 Cmpop::Eq => {
494 push_directive(tokens, "eq");
495 }
496 Cmpop::Ne => {
497 push_directive(tokens, "ne");
498 }
499 Cmpop::Lt => {
500 push_directive(tokens, "lt");
501 }
502 Cmpop::Le => {
503 push_directive(tokens, "le");
504 }
505 Cmpop::Gt => {
506 push_directive(tokens, "gt");
507 }
508 Cmpop::Ge => {
509 push_directive(tokens, "ge");
510 }
511 }
512 match &self.boolop {
513 Boolop::And => {
514 push_directive(tokens, "and");
515 }
516 Boolop::Xor => {
517 push_directive(tokens, "xor");
518 }
519 Boolop::Or => {
520 push_directive(tokens, "or");
521 }
522 }
523 if self.ftz {
524 push_directive(tokens, "ftz");
525 }
526 push_directive(tokens, "f16x2");
527 self.p.unparse_tokens(tokens);
528 tokens.push(PtxToken::Pipe);
529 self.q.unparse_tokens(tokens);
530 tokens.push(PtxToken::Comma);
531 self.a.unparse_tokens(tokens);
532 tokens.push(PtxToken::Comma);
533 self.b.unparse_tokens(tokens);
534 tokens.push(PtxToken::Comma);
535 if self.c_op { tokens.push(PtxToken::Exclaim); }
536 self.c.unparse_tokens(tokens);
537 tokens.push(PtxToken::Semicolon);
538 }
539 }
540
541 impl PtxUnparser for SetpCmpopBf16 {
542 fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
543 push_opcode(tokens, "setp");
544 match &self.cmpop {
545 Cmpop::Equ => {
546 push_directive(tokens, "equ");
547 }
548 Cmpop::Neu => {
549 push_directive(tokens, "neu");
550 }
551 Cmpop::Ltu => {
552 push_directive(tokens, "ltu");
553 }
554 Cmpop::Leu => {
555 push_directive(tokens, "leu");
556 }
557 Cmpop::Gtu => {
558 push_directive(tokens, "gtu");
559 }
560 Cmpop::Geu => {
561 push_directive(tokens, "geu");
562 }
563 Cmpop::Num => {
564 push_directive(tokens, "num");
565 }
566 Cmpop::Nan => {
567 push_directive(tokens, "nan");
568 }
569 Cmpop::Eq => {
570 push_directive(tokens, "eq");
571 }
572 Cmpop::Ne => {
573 push_directive(tokens, "ne");
574 }
575 Cmpop::Lt => {
576 push_directive(tokens, "lt");
577 }
578 Cmpop::Le => {
579 push_directive(tokens, "le");
580 }
581 Cmpop::Gt => {
582 push_directive(tokens, "gt");
583 }
584 Cmpop::Ge => {
585 push_directive(tokens, "ge");
586 }
587 }
588 push_directive(tokens, "bf16");
589 self.p.unparse_tokens(tokens);
590 tokens.push(PtxToken::Comma);
591 self.a.unparse_tokens(tokens);
592 tokens.push(PtxToken::Comma);
593 self.b.unparse_tokens(tokens);
594 tokens.push(PtxToken::Semicolon);
595 }
596 }
597
598 impl PtxUnparser for SetpCmpopBoolopBf16 {
599 fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
600 push_opcode(tokens, "setp");
601 match &self.cmpop {
602 Cmpop::Equ => {
603 push_directive(tokens, "equ");
604 }
605 Cmpop::Neu => {
606 push_directive(tokens, "neu");
607 }
608 Cmpop::Ltu => {
609 push_directive(tokens, "ltu");
610 }
611 Cmpop::Leu => {
612 push_directive(tokens, "leu");
613 }
614 Cmpop::Gtu => {
615 push_directive(tokens, "gtu");
616 }
617 Cmpop::Geu => {
618 push_directive(tokens, "geu");
619 }
620 Cmpop::Num => {
621 push_directive(tokens, "num");
622 }
623 Cmpop::Nan => {
624 push_directive(tokens, "nan");
625 }
626 Cmpop::Eq => {
627 push_directive(tokens, "eq");
628 }
629 Cmpop::Ne => {
630 push_directive(tokens, "ne");
631 }
632 Cmpop::Lt => {
633 push_directive(tokens, "lt");
634 }
635 Cmpop::Le => {
636 push_directive(tokens, "le");
637 }
638 Cmpop::Gt => {
639 push_directive(tokens, "gt");
640 }
641 Cmpop::Ge => {
642 push_directive(tokens, "ge");
643 }
644 }
645 match &self.boolop {
646 Boolop::And => {
647 push_directive(tokens, "and");
648 }
649 Boolop::Xor => {
650 push_directive(tokens, "xor");
651 }
652 Boolop::Or => {
653 push_directive(tokens, "or");
654 }
655 }
656 push_directive(tokens, "bf16");
657 self.p.unparse_tokens(tokens);
658 tokens.push(PtxToken::Comma);
659 self.a.unparse_tokens(tokens);
660 tokens.push(PtxToken::Comma);
661 self.b.unparse_tokens(tokens);
662 tokens.push(PtxToken::Comma);
663 if self.c_op { tokens.push(PtxToken::Exclaim); }
664 self.c.unparse_tokens(tokens);
665 tokens.push(PtxToken::Semicolon);
666 }
667 }
668
669 impl PtxUnparser for SetpCmpopBf16x2 {
670 fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
671 push_opcode(tokens, "setp");
672 match &self.cmpop {
673 Cmpop::Equ => {
674 push_directive(tokens, "equ");
675 }
676 Cmpop::Neu => {
677 push_directive(tokens, "neu");
678 }
679 Cmpop::Ltu => {
680 push_directive(tokens, "ltu");
681 }
682 Cmpop::Leu => {
683 push_directive(tokens, "leu");
684 }
685 Cmpop::Gtu => {
686 push_directive(tokens, "gtu");
687 }
688 Cmpop::Geu => {
689 push_directive(tokens, "geu");
690 }
691 Cmpop::Num => {
692 push_directive(tokens, "num");
693 }
694 Cmpop::Nan => {
695 push_directive(tokens, "nan");
696 }
697 Cmpop::Eq => {
698 push_directive(tokens, "eq");
699 }
700 Cmpop::Ne => {
701 push_directive(tokens, "ne");
702 }
703 Cmpop::Lt => {
704 push_directive(tokens, "lt");
705 }
706 Cmpop::Le => {
707 push_directive(tokens, "le");
708 }
709 Cmpop::Gt => {
710 push_directive(tokens, "gt");
711 }
712 Cmpop::Ge => {
713 push_directive(tokens, "ge");
714 }
715 }
716 push_directive(tokens, "bf16x2");
717 self.p.unparse_tokens(tokens);
718 tokens.push(PtxToken::Pipe);
719 self.q.unparse_tokens(tokens);
720 tokens.push(PtxToken::Comma);
721 self.a.unparse_tokens(tokens);
722 tokens.push(PtxToken::Comma);
723 self.b.unparse_tokens(tokens);
724 tokens.push(PtxToken::Semicolon);
725 }
726 }
727
728 impl PtxUnparser for SetpCmpopBoolopBf16x2 {
729 fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
730 push_opcode(tokens, "setp");
731 match &self.cmpop {
732 Cmpop::Equ => {
733 push_directive(tokens, "equ");
734 }
735 Cmpop::Neu => {
736 push_directive(tokens, "neu");
737 }
738 Cmpop::Ltu => {
739 push_directive(tokens, "ltu");
740 }
741 Cmpop::Leu => {
742 push_directive(tokens, "leu");
743 }
744 Cmpop::Gtu => {
745 push_directive(tokens, "gtu");
746 }
747 Cmpop::Geu => {
748 push_directive(tokens, "geu");
749 }
750 Cmpop::Num => {
751 push_directive(tokens, "num");
752 }
753 Cmpop::Nan => {
754 push_directive(tokens, "nan");
755 }
756 Cmpop::Eq => {
757 push_directive(tokens, "eq");
758 }
759 Cmpop::Ne => {
760 push_directive(tokens, "ne");
761 }
762 Cmpop::Lt => {
763 push_directive(tokens, "lt");
764 }
765 Cmpop::Le => {
766 push_directive(tokens, "le");
767 }
768 Cmpop::Gt => {
769 push_directive(tokens, "gt");
770 }
771 Cmpop::Ge => {
772 push_directive(tokens, "ge");
773 }
774 }
775 match &self.boolop {
776 Boolop::And => {
777 push_directive(tokens, "and");
778 }
779 Boolop::Xor => {
780 push_directive(tokens, "xor");
781 }
782 Boolop::Or => {
783 push_directive(tokens, "or");
784 }
785 }
786 push_directive(tokens, "bf16x2");
787 self.p.unparse_tokens(tokens);
788 tokens.push(PtxToken::Pipe);
789 self.q.unparse_tokens(tokens);
790 tokens.push(PtxToken::Comma);
791 self.a.unparse_tokens(tokens);
792 tokens.push(PtxToken::Comma);
793 self.b.unparse_tokens(tokens);
794 tokens.push(PtxToken::Comma);
795 if self.c_op { tokens.push(PtxToken::Exclaim); }
796 self.c.unparse_tokens(tokens);
797 tokens.push(PtxToken::Semicolon);
798 }
799 }
800
801}
802