1 /* $Id: esc.c,v 1.90 2018/07/25 14:03:26 tom Exp $ */
2
3 #include <vttest.h>
4 #include <esc.h>
5
6 /* This was needed for Solaris 2.5, whose standard I/O was broken */
7 #define FLUSH fflush(stdout)
8
9 static int soft_scroll;
10
11 /******************************************************************************/
12
13 static int pending_decstbm;
14 static int pending_decslrm;
15
16 static const char csi_7[] =
17 {ESC, '[', 0};
18
19 static const unsigned char csi_8[] =
20 {0x9b, 0};
21
22 const char *
csi_input(void)23 csi_input(void)
24 {
25 return input_8bits ? (const char *) csi_8 : csi_7;
26 }
27
28 const char *
csi_output(void)29 csi_output(void)
30 {
31 return output_8bits ? (const char *) csi_8 : csi_7;
32 }
33
34 /******************************************************************************/
35
36 static const char dcs_7[] =
37 {ESC, 'P', 0};
38
39 static const unsigned char dcs_8[] =
40 {0x90, 0};
41
42 const char *
dcs_input(void)43 dcs_input(void)
44 {
45 return input_8bits ? (const char *) dcs_8 : dcs_7;
46 }
47
48 const char *
dcs_output(void)49 dcs_output(void)
50 {
51 return output_8bits ? (const char *) dcs_8 : dcs_7;
52 }
53
54 /******************************************************************************/
55
56 static const char osc_7[] =
57 {ESC, ']', 0};
58 static const unsigned char osc_8[] =
59 {0x9d, 0};
60
61 const char *
osc_input(void)62 osc_input(void)
63 {
64 return input_8bits ? (const char *) osc_8 : osc_7;
65 }
66
67 const char *
osc_output(void)68 osc_output(void)
69 {
70 return output_8bits ? (const char *) osc_8 : osc_7;
71 }
72
73 /******************************************************************************/
74
75 static char ss2_7[] =
76 {ESC, 'N', 0};
77 static unsigned char ss2_8[] =
78 {0x8e, 0};
79
80 char *
ss2_input(void)81 ss2_input(void)
82 {
83 return input_8bits ? (char *) ss2_8 : ss2_7;
84 }
85
86 char *
ss2_output(void)87 ss2_output(void)
88 {
89 return output_8bits ? (char *) ss2_8 : ss2_7;
90 }
91
92 /******************************************************************************/
93
94 static char ss3_7[] =
95 {ESC, 'O', 0};
96 static unsigned char ss3_8[] =
97 {0x8f, 0};
98
99 char *
ss3_input(void)100 ss3_input(void)
101 {
102 return input_8bits ? (char *) ss3_8 : ss3_7;
103 }
104
105 char *
ss3_output(void)106 ss3_output(void)
107 {
108 return output_8bits ? (char *) ss3_8 : ss3_7;
109 }
110
111 /******************************************************************************/
112
113 static char st_7[] =
114 {ESC, '\\', 0};
115 static unsigned char st_8[] =
116 {0x9c, 0};
117
118 char *
st_input(void)119 st_input(void)
120 {
121 return input_8bits ? (char *) st_8 : st_7;
122 }
123
124 char *
st_output(void)125 st_output(void)
126 {
127 return output_8bits ? (char *) st_8 : st_7;
128 }
129
130 /******************************************************************************/
131
132 /*
133 * The actual number of nulls for padding is an estimate; it's working at
134 * 9600bd.
135 */
136 void
padding(int msecs)137 padding(int msecs)
138 {
139 if (use_padding) {
140 int count = (3 * msecs * tty_speed + DEFAULT_SPEED - 1) / DEFAULT_SPEED;
141 while (count-- > 0)
142 putchar(0);
143 }
144 }
145
146 void
extra_padding(int msecs)147 extra_padding(int msecs)
148 {
149 if (use_padding)
150 padding(soft_scroll ? (msecs * 4) : msecs);
151 }
152
153 int
println(const char * s)154 println(const char *s)
155 {
156 printf("%s\r\n", s);
157 if (LOG_ENABLED) {
158 fprintf(log_fp, "Text: %s\n", s);
159 }
160 return 1;
161 }
162
163 void
put_char(FILE * fp,int c)164 put_char(FILE *fp, int c)
165 {
166 if (fp == stdout)
167 putchar(c);
168 else {
169 c &= 0xff;
170 if (c <= ' ' || c >= '\177')
171 fprintf(fp, "<%d> ", c);
172 else
173 fprintf(fp, "%c ", c);
174 }
175 }
176
177 void
put_string(FILE * fp,const char * s)178 put_string(FILE *fp, const char *s)
179 {
180 while (*s != '\0')
181 put_char(fp, (int) *s++);
182 }
183
184 static void
va_out(FILE * fp,va_list ap,const char * fmt)185 va_out(FILE *fp, va_list ap, const char *fmt)
186 {
187 char temp[10];
188
189 while (*fmt != '\0') {
190 if (*fmt == '%') {
191 switch (*++fmt) {
192 case 'c':
193 put_char(fp, va_arg(ap, int));
194 break;
195 case 'd':
196 sprintf(temp, "%d", va_arg(ap, int));
197 put_string(fp, temp);
198 break;
199 case 'u':
200 sprintf(temp, "%u", va_arg(ap, unsigned));
201 put_string(fp, temp);
202 break;
203 case 's':
204 put_string(fp, va_arg(ap, char *));
205 break;
206 }
207 } else {
208 put_char(fp, (int) *fmt);
209 }
210 fmt++;
211 }
212 }
213
214 int
tprintf(const char * fmt,...)215 tprintf(const char *fmt,...)
216 {
217 va_list ap;
218 va_start(ap, fmt);
219 va_out(stdout, ap, fmt);
220 va_end(ap);
221 FLUSH;
222
223 if (LOG_ENABLED) {
224 fputs("Text: ", log_fp);
225 va_start(ap, fmt);
226 va_out(log_fp, ap, fmt);
227 va_end(ap);
228 fputs("\n", log_fp);
229 }
230 return 1;
231 }
232
233 /* CSI xxx */
234 void
do_csi(const char * fmt,...)235 do_csi(const char *fmt,...)
236 {
237 va_list ap;
238 va_start(ap, fmt);
239 fputs(csi_output(), stdout);
240 va_out(stdout, ap, fmt);
241 va_end(ap);
242 FLUSH;
243
244 if (LOG_ENABLED) {
245 fputs("Send: ", log_fp);
246 put_string(log_fp, csi_output());
247 va_start(ap, fmt);
248 va_out(log_fp, ap, fmt);
249 va_end(ap);
250 fputs("\n", log_fp);
251 }
252 }
253
254 /* DCS xxx ST */
255 void
do_dcs(const char * fmt,...)256 do_dcs(const char *fmt,...)
257 {
258 va_list ap;
259 va_start(ap, fmt);
260 fputs(dcs_output(), stdout);
261 va_out(stdout, ap, fmt);
262 va_end(ap);
263 fputs(st_output(), stdout);
264 FLUSH;
265
266 if (LOG_ENABLED) {
267 va_start(ap, fmt);
268 fputs("Send: ", log_fp);
269 put_string(log_fp, dcs_output());
270 va_out(log_fp, ap, fmt);
271 va_end(ap);
272 put_string(log_fp, st_output());
273 fputs("\n", log_fp);
274 }
275 }
276
277 /* DCS xxx ST */
278 void
do_osc(const char * fmt,...)279 do_osc(const char *fmt,...)
280 {
281 va_list ap;
282 va_start(ap, fmt);
283 fputs(osc_output(), stdout);
284 va_out(stdout, ap, fmt);
285 va_end(ap);
286 fputs(st_output(), stdout);
287 FLUSH;
288
289 if (LOG_ENABLED) {
290 va_start(ap, fmt);
291 fputs("Send: ", log_fp);
292 put_string(log_fp, osc_output());
293 va_out(log_fp, ap, fmt);
294 va_end(ap);
295 put_string(log_fp, st_output());
296 fputs("\n", log_fp);
297 }
298 }
299
300 int
print_chr(int c)301 print_chr(int c)
302 {
303 printf("%c", c);
304
305 if (LOG_ENABLED) {
306 fprintf(log_fp, "Send: ");
307 put_char(log_fp, c);
308 fputs("\n", log_fp);
309 }
310 return 1;
311 }
312
313 int
print_str(const char * s)314 print_str(const char *s)
315 {
316 int result = (int) strlen(s);
317 printf("%s", s);
318
319 if (LOG_ENABLED) {
320 fprintf(log_fp, "Send: ");
321 while (*s) {
322 put_char(log_fp, *s++);
323 }
324 fputs("\n", log_fp);
325 }
326 return result;
327 }
328
329 void
esc(const char * s)330 esc(const char *s)
331 {
332 printf("%c%s", ESC, s);
333
334 if (LOG_ENABLED) {
335 fprintf(log_fp, "Send: ");
336 put_char(log_fp, ESC);
337 put_string(log_fp, s);
338 fputs("\n", log_fp);
339 }
340 }
341
342 void
brc(int pn,int c)343 brc(int pn, int c)
344 {
345 do_csi("%d%c", pn, c);
346 }
347
348 void
brc2(int pn1,int pn2,int c)349 brc2(int pn1, int pn2, int c)
350 {
351 do_csi("%d;%d%c", pn1, pn2, c);
352 }
353
354 void
brc3(int pn1,int pn2,int pn3,int c)355 brc3(int pn1, int pn2, int pn3, int c)
356 {
357 do_csi("%d;%d;%d%c", pn1, pn2, pn3, c);
358 }
359
360 /******************************************************************************/
361
362 void
cbt(int pn)363 cbt(int pn) /* Cursor Back Tab */
364 {
365 brc(pn, 'Z');
366 }
367
368 void
cha(int pn)369 cha(int pn) /* Cursor Character Absolute */
370 {
371 brc(pn, 'G');
372 }
373
374 void
cht(int pn)375 cht(int pn) /* Cursor Forward Tabulation */
376 {
377 brc(pn, 'I');
378 }
379
380 void
cnl(int pn)381 cnl(int pn) /* Cursor Next Line */
382 {
383 brc(pn, 'E');
384 }
385
386 void
cpl(int pn)387 cpl(int pn) /* Cursor Previous Line */
388 {
389 brc(pn, 'F');
390 }
391
392 void
cub(int pn)393 cub(int pn) /* Cursor Backward */
394 {
395 brc(pn, 'D');
396 padding(2);
397 }
398
399 void
cud(int pn)400 cud(int pn) /* Cursor Down */
401 {
402 brc(pn, 'B');
403 extra_padding(2);
404 }
405
406 void
cuf(int pn)407 cuf(int pn) /* Cursor Forward */
408 {
409 brc(pn, 'C');
410 padding(2);
411 }
412
413 int
cup(int pn1,int pn2)414 cup(int pn1, int pn2) /* Cursor Position */
415 {
416 brc2(pn1, pn2, 'H');
417 padding(5); /* 10 for vt220 */
418 return 1; /* used for indenting */
419 }
420
421 void
cuu(int pn)422 cuu(int pn) /* Cursor Up */
423 {
424 brc(pn, 'A');
425 extra_padding(2);
426 }
427
428 void
da(void)429 da(void) /* Device Attributes */
430 {
431 brc(0, 'c');
432 }
433
434 void
decaln(void)435 decaln(void) /* Screen Alignment Display */
436 {
437 esc("#8");
438 }
439
440 void
decarm(int flag)441 decarm(int flag) /* DECARM autorepeat */
442 {
443 if (flag)
444 sm("?8"); /* autorepeat */
445 else
446 rm("?8"); /* no autorepeat */
447 }
448
449 void
decawm(int flag)450 decawm(int flag) /* DECAWM autowrap */
451 {
452 if (flag)
453 sm("?7"); /* autowrap */
454 else
455 rm("?7"); /* no autowrap */
456 }
457
458 void
decbi(void)459 decbi(void) /* VT400: Back Index */
460 {
461 esc("6");
462 padding(40);
463 }
464
465 void
decbkm(int flag)466 decbkm(int flag) /* VT400: Backarrow key */
467 {
468 if (flag)
469 sm("?67"); /* backspace */
470 else
471 rm("?67"); /* delete */
472 }
473
474 void
decncsm(int flag)475 decncsm(int flag) /* VT500: DECNCSM no clear on DECCOLM */
476 {
477 if (flag)
478 sm("?95"); /* no clear */
479 else
480 rm("?95"); /* clear */
481 }
482
483 void
deccara(int top,int left,int bottom,int right,int attr)484 deccara(int top, int left, int bottom, int right, int attr)
485 {
486 do_csi("%d;%d;%d;%d;%d$r", top, left, bottom, right, attr);
487 }
488
489 void
decckm(int flag)490 decckm(int flag) /* DECCKM Cursor Keys */
491 {
492 if (flag)
493 sm("?1"); /* application */
494 else
495 rm("?1"); /* normal */
496 }
497
498 void
deccolm(int flag)499 deccolm(int flag) /* DECCOLM 80/132 Columns */
500 {
501 if (flag)
502 sm("?3"); /* 132 columns */
503 else
504 rm("?3"); /* 80 columns */
505 }
506
507 void
deccra(int Pts,int Pl,int Pbs,int Prs,int Pps,int Ptd,int Pld,int Ppd)508 deccra(int Pts, int Pl, int Pbs, int Prs, int Pps, int Ptd, int Pld, int Ppd)
509 {
510 do_csi("%d;%d;%d;%d;%d;%d;%d;%d;$v",
511 Pts, /* top-line border */
512 Pl, /* left-line border */
513 Pbs, /* bottom-line border */
514 Prs, /* right-line border */
515 Pps, /* source page number */
516 Ptd, /* destination top-line border */
517 Pld, /* destination left-line border */
518 Ppd); /* destination page number */
519 }
520
521 int
decdc(int pn)522 decdc(int pn) /* VT400 Delete Column */
523 {
524 do_csi("%d'~", pn);
525 padding(10 * pn);
526 return 1;
527 }
528
529 void
decefr(int top,int left,int bottom,int right)530 decefr(int top, int left, int bottom, int right) /* DECterm Enable filter rectangle */
531 {
532 do_csi("%d;%d;%d;%d'w", top, left, bottom, right);
533 }
534
535 void
decelr(int all_or_one,int pixels_or_cells)536 decelr(int all_or_one, int pixels_or_cells) /* DECterm Enable Locator Reporting */
537 {
538 do_csi("%d;%d'z", all_or_one, pixels_or_cells);
539 }
540
541 void
decera(int top,int left,int bottom,int right)542 decera(int top, int left, int bottom, int right) /* VT400 Erase Rectangular area */
543 {
544 do_csi("%d;%d;%d;%d$z", top, left, bottom, right);
545 }
546
547 void
decdhl(int lower)548 decdhl(int lower) /* Double Height Line (also double width) */
549 {
550 if (lower)
551 esc("#4");
552 else
553 esc("#3");
554 }
555
556 void
decdwl(void)557 decdwl(void) /* Double Wide Line */
558 {
559 esc("#6");
560 }
561
562 void
decfi(void)563 decfi(void) /* VT400: Forward Index */
564 {
565 esc("9");
566 padding(40);
567 }
568
569 void
decfra(int c,int top,int left,int bottom,int right)570 decfra(int c, int top, int left, int bottom, int right) /* VT400 Fill Rectangular area */
571 {
572 do_csi("%d;%d;%d;%d;%d$x", c, top, left, bottom, right);
573 }
574
575 void
decid(void)576 decid(void) /* required for VT52, not recommended above VT100 */
577 {
578 esc("Z"); /* Identify */
579 }
580
581 int
decic(int pn)582 decic(int pn) /* VT400 Insert Column */
583 {
584 do_csi("%d'}", pn);
585 padding(10 * pn);
586 return 1;
587 }
588
589 void
deckbum(int flag)590 deckbum(int flag) /* VT400: Keyboard Usage */
591 {
592 if (flag)
593 sm("?68"); /* data processing */
594 else
595 rm("?68"); /* typewriter */
596 }
597
598 void
deckpam(void)599 deckpam(void) /* Keypad Application Mode */
600 {
601 esc("=");
602 }
603
604 void
deckpm(int flag)605 deckpm(int flag) /* VT400: Keyboard Position */
606 {
607 if (flag)
608 sm("?81"); /* position reports */
609 else
610 rm("?81"); /* character codes */
611 }
612
613 void
deckpnm(void)614 deckpnm(void) /* Keypad Numeric Mode */
615 {
616 esc(">");
617 }
618
619 void
decll(const char * ps)620 decll(const char *ps) /* Load LEDs */
621 {
622 do_csi("%sq", ps);
623 }
624
625 void
decnkm(int flag)626 decnkm(int flag) /* VT400: Numeric Keypad */
627 {
628 if (flag)
629 sm("?66"); /* application */
630 else
631 rm("?66"); /* numeric */
632 }
633
634 void
decom(int flag)635 decom(int flag) /* DECOM Origin */
636 {
637 if (flag)
638 sm("?6"); /* relative */
639 else
640 rm("?6"); /* absolute */
641 }
642
643 void
decpex(int flag)644 decpex(int flag) /* VT220: printer extent mode */
645 {
646 if (flag)
647 sm("?19"); /* full screen (page) */
648 else
649 rm("?19"); /* scrolling region */
650 }
651
652 void
decpff(int flag)653 decpff(int flag) /* VT220: print form feed mode */
654 {
655 if (flag)
656 sm("?18"); /* form feed */
657 else
658 rm("?18"); /* no form feed */
659 }
660
661 void
decnrcm(int flag)662 decnrcm(int flag) /* VT220: National replacement character set */
663 {
664 if (flag)
665 sm("?42"); /* national */
666 else
667 rm("?42"); /* multinational */
668 }
669
670 void
decrara(int top,int left,int bottom,int right,int attr)671 decrara(int top, int left, int bottom, int right, int attr)
672 {
673 do_csi("%d;%d;%d;%d;%d$t", top, left, bottom, right, attr);
674 }
675
676 void
decrc(void)677 decrc(void) /* Restore Cursor */
678 {
679 esc("8");
680 }
681
682 void
decreqtparm(int pn)683 decreqtparm(int pn) /* Request Terminal Parameters */
684 {
685 brc(pn, 'x');
686 }
687
688 void
decrqlp(int mode)689 decrqlp(int mode) /* DECterm Request Locator Position */
690 {
691 do_csi("%d'|", mode);
692 }
693
694 void
decrqpsr(int mode)695 decrqpsr(int mode) /* Request presentation report */
696 {
697 do_csi("%d$w", mode);
698 }
699
700 void
decrqss(const char * pn)701 decrqss(const char *pn) /* VT200 Request Status-String */
702 {
703 do_dcs("$q%s", pn);
704 }
705
706 void
decsace(int flag)707 decsace(int flag) /* VT400 Select attribute change extent */
708 {
709 do_csi("%d*x", flag ? 2 : 0);
710 }
711
712 void
decsasd(int pn)713 decsasd(int pn) /* VT200 Select active status display */
714 {
715 do_csi("%d$}", pn);
716 }
717
718 void
decsc(void)719 decsc(void) /* Save Cursor */
720 {
721 esc("7");
722 }
723
724 void
decsca(int pn1)725 decsca(int pn1) /* VT200 select character attribute (protect) */
726 {
727 do_csi("%d\"q", pn1);
728 }
729
730 void
decsclm(int flag)731 decsclm(int flag) /* Scrolling mode (smooth/jump) */
732 {
733 if (flag)
734 sm("?4"); /* smooth scrolling */
735 else
736 rm("?4"); /* jump-scrolling scrolling */
737 soft_scroll = flag;
738 }
739
740 void
decscnm(int flag)741 decscnm(int flag) /* Screen mode (inverse-video) */
742 {
743 if (flag)
744 sm("?5"); /* inverse video */
745 else
746 rm("?5"); /* normal video */
747 padding(200);
748 }
749
750 void
decsed(int pn1)751 decsed(int pn1) /* VT200 selective erase in display */
752 {
753 do_csi("?%dJ", pn1);
754 }
755
756 void
decsel(int pn1)757 decsel(int pn1) /* VT200 selective erase in line */
758 {
759 do_csi("?%dK", pn1);
760 }
761
762 void
decsera(int top,int left,int bottom,int right)763 decsera(int top, int left, int bottom, int right) /* VT400 Selective erase rectangular area */
764 {
765 do_csi("%d;%d;%d;%d${", top, left, bottom, right);
766 }
767
768 void
decsle(int mode)769 decsle(int mode) /* DECterm Select Locator Events */
770 {
771 do_csi("%d'{", mode);
772 }
773
774 void /* VT300 Set columns per page */
decscpp(int cols)775 decscpp(int cols)
776 {
777 if (cols >= 0) {
778 do_csi("%d$|", cols);
779 } else {
780 do_csi("$|");
781 }
782 }
783
784 void /* VT300 Set lines per page */
decslpp(int rows)785 decslpp(int rows)
786 {
787 /*
788 * DEC defines 24, 25, 36, 48, 72 and 144.
789 * XTerm uses codes up to 24 for window operations,
790 * and 24 and up for this feature.
791 */
792 do_csi("%dt", rows);
793 }
794
795 void
decsnls(int pn)796 decsnls(int pn) /* VT400 Select number of lines per screen */
797 {
798 do_csi("%d*|", pn);
799 }
800
801 void
decssdt(int pn)802 decssdt(int pn) /* VT200 Select status line type */
803 {
804 do_csi("%d$~", pn);
805 }
806
807 void
decstbm(int pn1,int pn2)808 decstbm(int pn1, int pn2) /* Set Top and Bottom Margins */
809 {
810 if (pn1 || pn2) {
811 brc2(pn1, pn2, 'r');
812 pending_decstbm = 1;
813 } else {
814 esc("[r");
815 pending_decstbm = 0;
816 }
817 }
818
819 void
np(void)820 np(void) /* NP - next page */
821 {
822 do_csi("U");
823 }
824
825 void
pp(void)826 pp(void) /* PP - previous page */
827 {
828 do_csi("V");
829 }
830
831 void
ppa(int n)832 ppa(int n) /* PPA - Page Position Absolute */
833 {
834 do_csi("%d P", n);
835 }
836
837 void
ppb(int n)838 ppb(int n) /* PPB - Page Position Backward */
839 {
840 do_csi("%d R", n);
841 }
842
843 void
ppr(int n)844 ppr(int n) /* PPR - Page Position Relative */
845 {
846 do_csi("%d Q", n);
847 }
848
849 /*
850 * Reset top/bottom margins, but only if we set them to non-default.
851 */
852 void
reset_decstbm(void)853 reset_decstbm(void)
854 {
855 if (pending_decstbm) {
856 decstbm(0, 0);
857 }
858 }
859
860 void
decslrm(int pn1,int pn2)861 decslrm(int pn1, int pn2) /* Set Left and Right Margins */
862 {
863 if (pn1 || pn2) {
864 brc2(pn1, pn2, 's');
865 pending_decslrm = 1;
866 } else {
867 esc("[s");
868 pending_decslrm = 0;
869 }
870 }
871
872 /*
873 * Reset left/right margins, but only if we set them to non-default.
874 */
875 void
reset_decslrm(void)876 reset_decslrm(void)
877 {
878 if (pending_decslrm) {
879 decslrm(0, 0);
880 }
881 }
882
883 void
decstr(void)884 decstr(void) /* VT200 Soft terminal reset */
885 {
886 do_csi("!p");
887 }
888
889 void
decswl(void)890 decswl(void) /* Single Width Line */
891 {
892 esc("#5");
893 }
894
895 void
dectst(int pn)896 dectst(int pn) /* Invoke Confidence Test */
897 {
898 brc2(2, pn, 'y');
899 #ifdef UNIX
900 fflush(stdout);
901 #endif
902 }
903
904 void
dsr(int pn)905 dsr(int pn) /* Device Status Report */
906 {
907 brc(pn, 'n');
908 }
909
910 void
ed(int pn)911 ed(int pn) /* Erase in Display */
912 {
913 brc(pn, 'J');
914 padding(50);
915 }
916
917 void
el(int pn)918 el(int pn) /* Erase in Line */
919 {
920 brc(pn, 'K');
921 padding(3); /* 4 for vt400 */
922 }
923
924 void
ech(int pn)925 ech(int pn) /* Erase character(s) */
926 {
927 brc(pn, 'X');
928 }
929
930 void
hpa(int pn)931 hpa(int pn) /* HPA - Horizontal Position Absolute */
932 {
933 brc(pn, '`');
934 }
935
936 void
hpr(int pn)937 hpr(int pn) /* HPR - Horizontal Position Relative */
938 {
939 brc(pn, 'a');
940 }
941
942 void
hts(void)943 hts(void) /* Horizontal Tabulation Set */
944 {
945 esc("H");
946 }
947
948 void
hvp(int pn1,int pn2)949 hvp(int pn1, int pn2) /* Horizontal and Vertical Position */
950 {
951 brc2(pn1, pn2, 'f');
952 }
953
954 void
ind(void)955 ind(void) /* Index */
956 {
957 esc("D");
958 padding(20); /* vt220 */
959 }
960
961 /* The functions beginning "mc_" are variations of Media Copy (MC) */
962
963 void
mc_autoprint(int flag)964 mc_autoprint(int flag) /* VT220: auto print mode */
965 {
966 do_csi("?%di", flag ? 5 : 4);
967 }
968
969 void
mc_printer_controller(int flag)970 mc_printer_controller(int flag) /* VT220: printer controller mode */
971 {
972 do_csi("%di", flag ? 5 : 4);
973 }
974
975 void
mc_print_page(void)976 mc_print_page(void) /* VT220: print page */
977 {
978 do_csi("i");
979 }
980
981 void
mc_print_composed(void)982 mc_print_composed(void) /* VT300: print composed main display */
983 {
984 do_csi("?10i");
985 }
986
987 void
mc_print_all_pages(void)988 mc_print_all_pages(void) /* VT300: print composed all pages */
989 {
990 do_csi("?11i");
991 }
992
993 void
mc_print_cursor_line(void)994 mc_print_cursor_line(void) /* VT220: print cursor line */
995 {
996 do_csi("?1i");
997 }
998
999 void
mc_printer_start(int flag)1000 mc_printer_start(int flag) /* VT300: start/stop printer-to-host session */
1001 {
1002 do_csi("?%di", flag ? 9 : 8);
1003 }
1004
1005 void
mc_printer_assign(int flag)1006 mc_printer_assign(int flag) /* VT300: assign/release printer to active session */
1007 {
1008 do_csi("?%di", flag ? 18 : 19);
1009 }
1010
1011 void
nel(void)1012 nel(void) /* Next Line */
1013 {
1014 esc("E");
1015 }
1016
1017 void
rep(int pn)1018 rep(int pn) /* Repeat */
1019 {
1020 do_csi("%db", pn);
1021 }
1022
1023 void
ri(void)1024 ri(void) /* Reverse Index */
1025 {
1026 esc("M");
1027 extra_padding(5); /* 14 on vt220 */
1028 }
1029
1030 void
ris(void)1031 ris(void) /* Reset to Initial State */
1032 {
1033 esc("c");
1034 #ifdef UNIX
1035 fflush(stdout);
1036 #endif
1037 }
1038
1039 void
rm(const char * ps)1040 rm(const char *ps) /* Reset Mode */
1041 {
1042 do_csi("%sl", ps);
1043 }
1044
1045 void
s8c1t(int flag)1046 s8c1t(int flag) /* Tell terminal to respond with 7-bit or 8-bit controls */
1047 {
1048 if ((input_8bits = flag) != FALSE)
1049 esc(" G"); /* select 8-bit controls */
1050 else
1051 esc(" F"); /* select 7-bit controls */
1052 fflush(stdout);
1053 zleep(300);
1054 }
1055
1056 /*
1057 * If g is zero,
1058 * designate G0 as character set c
1059 * designate G1 as character set B (ASCII)
1060 * shift-in (select G0 into GL).
1061 * If g is nonzero
1062 * designate G0 as character set B (ASCII)
1063 * designate G1 as character set c
1064 * shift-out (select G1 into GL).
1065 * See also scs_normal() and scs_graphics().
1066 */
1067 void
scs(int g,int c)1068 scs(int g, int c) /* Select character Set */
1069 {
1070 char temp[10];
1071
1072 sprintf(temp, "%c%c", g ? ')' : '(', c);
1073 esc(temp);
1074
1075 sprintf(temp, "%c%c", g ? '(' : ')', 'B');
1076 esc(temp);
1077
1078 print_chr(g ? SO : SI);
1079 padding(4);
1080 }
1081
1082 void
sd(int pn)1083 sd(int pn) /* Scroll Down */
1084 {
1085 brc(pn, 'T');
1086 }
1087
1088 void
sgr(const char * ps)1089 sgr(const char *ps) /* Select Graphic Rendition */
1090 {
1091 do_csi("%sm", ps);
1092 padding(2);
1093 }
1094
1095 void
sl(int pn)1096 sl(int pn) /* Scroll Left */
1097 {
1098 do_csi("%d @", pn);
1099 }
1100
1101 void
sm(const char * ps)1102 sm(const char *ps) /* Set Mode */
1103 {
1104 do_csi("%sh", ps);
1105 }
1106
1107 void
sr(int pn)1108 sr(int pn) /* Scroll Right */
1109 {
1110 do_csi("%d A", pn);
1111 }
1112
1113 void
srm(int flag)1114 srm(int flag) /* VT400: Send/Receive mode */
1115 {
1116 if (flag)
1117 sm("12"); /* local echo off */
1118 else
1119 rm("12"); /* local echo on */
1120 }
1121
1122 void
su(int pn)1123 su(int pn) /* Scroll Up */
1124 {
1125 brc(pn, 'S');
1126 extra_padding(5);
1127 }
1128
1129 void
tbc(int pn)1130 tbc(int pn) /* Tabulation Clear */
1131 {
1132 brc(pn, 'g');
1133 }
1134
1135 void
dch(int pn)1136 dch(int pn) /* Delete character */
1137 {
1138 brc(pn, 'P');
1139 }
1140
1141 void
ich(int pn)1142 ich(int pn) /* Insert character -- not in VT102 */
1143 {
1144 brc(pn, '@');
1145 }
1146
1147 void
dl(int pn)1148 dl(int pn) /* Delete line */
1149 {
1150 brc(pn, 'M');
1151 }
1152
1153 void
il(int pn)1154 il(int pn) /* Insert line */
1155 {
1156 brc(pn, 'L');
1157 }
1158
1159 void
vpa(int pn)1160 vpa(int pn) /* Vertical Position Absolute */
1161 {
1162 brc(pn, 'd');
1163 }
1164
1165 void
vpr(int pn)1166 vpr(int pn) /* Vertical Position Relative */
1167 {
1168 brc(pn, 'e');
1169 }
1170
1171 void
vt52cub1(void)1172 vt52cub1(void) /* cursor left */
1173 {
1174 esc("D");
1175 padding(5);
1176 }
1177
1178 void
vt52cud1(void)1179 vt52cud1(void) /* cursor down */
1180 {
1181 esc("B");
1182 padding(5);
1183 }
1184
1185 void
vt52cuf1(void)1186 vt52cuf1(void) /* cursor right */
1187 {
1188 esc("C");
1189 padding(5);
1190 }
1191
1192 void
vt52cup(int l,int c)1193 vt52cup(int l, int c) /* direct cursor address */
1194 {
1195 char temp[10];
1196 sprintf(temp, "Y%c%c", l + 31, c + 31);
1197 esc(temp);
1198 padding(5);
1199 }
1200
1201 void
vt52cuu1(void)1202 vt52cuu1(void) /* cursor up */
1203 {
1204 esc("A");
1205 padding(5);
1206 }
1207
1208 void
vt52ed(void)1209 vt52ed(void) /* erase to end of screen */
1210 {
1211 esc("J");
1212 padding(5);
1213 }
1214
1215 void
vt52el(void)1216 vt52el(void) /* erase to end of line */
1217 {
1218 esc("K");
1219 padding(5);
1220 }
1221
1222 void
vt52home(void)1223 vt52home(void) /* cursor to home */
1224 {
1225 esc("H");
1226 padding(5);
1227 }
1228
1229 void
vt52ri(void)1230 vt52ri(void) /* reverse line feed */
1231 {
1232 esc("I");
1233 padding(5);
1234 }
1235