← Back to branch summary

~ubuntu-branches/ubuntu/saucy/fdclone/saucy-proposed

« back to all changes in this revision

Viewing changes to backend.c

  • Committer: Package Import Robot
  • Author(s): Elías Alejandro Año Mendoza
  • Date: 2013-03-31 20:19:19 UTC
  • mfrom: (1.1.5)
  • Revision ID: package-import@ubuntu.com-20130331201919-vd2f75ssuh1sdctw
Tags: 3.01-1
* New upstream release
* Updated Standard-Version to 3.9.4
* Bump debhelper to 9
* debian/rules enabled hardening build flags

Show diffs side-by-side

added added

removed removed

Lines of Context:
backend.c
21
21
#define MAXTABSTOP              255
22
22
#define MAXLASTUCS2             (MAXNFLEN - 1)
23
23
 
 
24
typedef struct _ptystat_t {
 
25
        short x, y;
 
26
        short fg, bg;
 
27
        u_short attr;
 
28
} ptystat_t;
 
29
 
24
30
typedef struct _ptyterm_t {
25
 
        short cur_x, cur_y;
 
31
        ptystat_t cur, save;
26
32
        short min_x, min_y;
27
33
        short max_x, max_y;
28
 
        short save_x, save_y;
29
34
        short min_scroll, max_scroll;
30
35
        short last1, last2;
31
 
        short fg, bg;
32
36
        u_char escmode;
33
37
        u_char nparam;
34
38
        u_char nchar;
39
43
#ifdef  DEP_KCONV
40
44
        u_short last_ucs2[MAXLASTUCS2];
41
45
#endif
42
 
        u_short attr;
43
46
        u_short termflags;
44
47
        char codeselect[MAXESCCHAR + 2];
45
48
} ptyterm_t;
127
130
int w;
128
131
{
129
132
        if (w >= 0) {
130
 
                pty[w].fg = pty[w].bg = (short)-1;
131
 
                pty[w].attr = (u_short)0;
 
133
                pty[w].cur.attr = (u_short)0;
 
134
                pty[w].cur.fg = pty[w].cur.bg = (short)-1;
132
135
        }
133
136
        else if (last_attr || last_fg >= (short)0 || last_bg >= (short)0) {
134
137
                putterm(T_NORMAL);
188
191
        }
189
192
 
190
193
        if (clean) {
191
 
                pty[w].cur_x = pty[w].save_x = pty[w].min_x;
192
 
                pty[w].cur_y = pty[w].save_y = pty[w].max_y - 1;
 
194
                pty[w].cur.x = pty[w].min_x;
 
195
                pty[w].cur.y = pty[w].max_y - 1;
193
196
                pty[w].min_scroll = pty[w].min_y;
194
197
                pty[w].max_scroll = pty[w].max_y - 1;
195
198
                pty[w].escmode = '\0';
202
205
                resettermattr(w);
203
206
                resettermcode(w);
204
207
                resettabstop(w);
 
208
                memcpy((char *)&(pty[w].save), (char *)&(pty[w].cur),
 
209
                        sizeof(pty[w].save));
205
210
        }
206
211
        else {
207
 
                pty[w].cur_x += pty[w].min_x - min_x;
208
 
                pty[w].cur_y += pty[w].min_y - min_y;
209
 
                pty[w].save_x += pty[w].save_x - min_x;
210
 
                pty[w].save_y += pty[w].save_y - min_y;
 
212
                pty[w].cur.x += pty[w].min_x - min_x;
 
213
                pty[w].cur.y += pty[w].min_y - min_y;
 
214
                pty[w].save.x += pty[w].min_x - min_x;
 
215
                pty[w].save.y += pty[w].min_y - min_y;
211
216
                pty[w].min_scroll += pty[w].min_y - min_y;
212
217
                pty[w].max_scroll += pty[w].max_y - max_y;
213
 
                biasxy(w, &(pty[w].cur_x), &(pty[w].cur_y));
214
 
                biasxy(w, &(pty[w].save_x), &(pty[w].save_y));
 
218
                biasxy(w, &(pty[w].cur.x), &(pty[w].cur.y));
 
219
                biasxy(w, &(pty[w].save.x), &(pty[w].save.y));
215
220
                biasxy(w, NULL, &(pty[w].min_scroll));
216
221
                biasxy(w, NULL, &(pty[w].max_scroll));
217
222
        }
234
239
static VOID NEAR settermattr(w)
235
240
int w;
236
241
{
237
 
        if ((last_fg >= (short)0 && pty[w].fg < (short)0)
238
 
        || (last_bg >= (short)0 && pty[w].bg < (short)0))
 
242
        if ((last_fg >= (short)0 && pty[w].cur.fg < (short)0)
 
243
        || (last_bg >= (short)0 && pty[w].cur.bg < (short)0))
239
244
                resettermattr(-1);
240
245
 
241
 
        if (last_attr != pty[w].attr) {
 
246
        if (last_attr != pty[w].cur.attr) {
242
247
                putterm(T_NORMAL);
243
248
                last_fg = last_bg = (short)-1;
244
 
                if (pty[w].attr & A_BOLD) putterm(T_BOLD);
245
 
                if (pty[w].attr & A_REVERSE) putterm(T_REVERSE);
246
 
                if (pty[w].attr & A_DIM) putterm(T_DIM);
247
 
                if (pty[w].attr & A_BLINK) putterm(T_BLINK);
248
 
                if (pty[w].attr & A_STANDOUT) putterm(T_STANDOUT);
249
 
                if (pty[w].attr & A_UNDERLINE) putterm(T_UNDERLINE);
250
 
                last_attr = pty[w].attr;
 
249
                if (pty[w].cur.attr & A_BOLD) putterm(T_BOLD);
 
250
                if (pty[w].cur.attr & A_REVERSE) putterm(T_REVERSE);
 
251
                if (pty[w].cur.attr & A_DIM) putterm(T_DIM);
 
252
                if (pty[w].cur.attr & A_BLINK) putterm(T_BLINK);
 
253
                if (pty[w].cur.attr & A_STANDOUT) putterm(T_STANDOUT);
 
254
                if (pty[w].cur.attr & A_UNDERLINE) putterm(T_UNDERLINE);
 
255
                last_attr = pty[w].cur.attr;
251
256
        }
252
257
 
253
 
        if (last_fg != pty[w].fg && pty[w].fg >= (short)0) {
254
 
                if (tputparam(T_FGCOLOR, pty[w].fg, 0, 1) < 0)
255
 
                        tprintf("\033[%dm", 1, pty[w].fg + ANSI_NORMAL);
256
 
                last_fg = pty[w].fg;
 
258
        if (last_fg != pty[w].cur.fg && pty[w].cur.fg >= (short)0) {
 
259
                if (tputparam(T_FGCOLOR, pty[w].cur.fg, 0, 1) < 0)
 
260
                        tprintf("\033[%dm", 1, pty[w].cur.fg + ANSI_NORMAL);
 
261
                last_fg = pty[w].cur.fg;
257
262
        }
258
 
        if (last_bg != pty[w].bg && pty[w].bg >= (short)0) {
259
 
                if (tputparam(T_BGCOLOR, pty[w].bg, 0, 1) < 0)
260
 
                        tprintf("\033[%dm", 1, pty[w].bg + ANSI_REVERSE);
261
 
                last_bg = pty[w].bg;
 
263
        if (last_bg != pty[w].cur.bg && pty[w].cur.bg >= (short)0) {
 
264
                if (tputparam(T_BGCOLOR, pty[w].cur.bg, 0, 1) < 0)
 
265
                        tprintf("\033[%dm", 1, pty[w].cur.bg + ANSI_REVERSE);
 
266
                last_bg = pty[w].cur.bg;
262
267
        }
263
268
}
264
269
 
285
290
static VOID NEAR surelocate(w, forced)
286
291
int w, forced;
287
292
{
288
 
        if (!forced && pty[w].cur_x == last_x && pty[w].cur_y == last_y)
 
293
        if (!forced && pty[w].cur.x == last_x && pty[w].cur.y == last_y)
289
294
                return;
290
295
 
291
296
        resettermattr(-1);
292
 
        locate(pty[w].cur_x, pty[w].cur_y);
293
 
        last_x = pty[w].cur_x;
294
 
        last_y = pty[w].cur_y;
 
297
        locate(pty[w].cur.x, pty[w].cur.y);
 
298
        last_x = pty[w].cur.x;
 
299
        last_y = pty[w].cur.y;
295
300
}
296
301
 
297
302
static VOID NEAR reallocate(w, x, y)
 
303
int w, x, y;
298
304
{
299
 
        if (pty[w].attr || pty[w].fg >= (short)0 || pty[w].bg >= (short)0) {
 
305
        if (pty[w].cur.attr
 
306
        || pty[w].cur.fg >= (short)0 || pty[w].cur.bg >= (short)0) {
300
307
                surelocate(w, 1);
301
308
                settermattr(w);
302
309
        }
303
310
 
304
 
        pty[w].cur_x = x;
305
 
        pty[w].cur_y = y;
306
 
        biasxy(w, &(pty[w].cur_x), &(pty[w].cur_y));
307
 
        locate(pty[w].cur_x, pty[w].cur_y);
 
311
        pty[w].cur.x = x;
 
312
        pty[w].cur.y = y;
 
313
        biasxy(w, &(pty[w].cur.x), &(pty[w].cur.y));
 
314
        locate(pty[w].cur.x, pty[w].cur.y);
308
315
        tflush();
309
 
        last_x = pty[w].cur_x;
310
 
        last_y = pty[w].cur_y;
 
316
        last_x = pty[w].cur.x;
 
317
        last_y = pty[w].cur.y;
311
318
}
312
319
 
313
320
#ifdef  SIGWINCH
342
349
 
343
350
                if (xmax != pty[i].max_x - pty[i].min_x
344
351
                || ymax != pty[i].max_y - pty[i].min_y) {
345
 
                        pty[i].cur_x = pty[i].save_x = pty[i].min_x;
346
 
                        pty[i].cur_y = pty[i].save_y = pty[i].max_y - 1;
 
352
                        pty[i].cur.x = pty[i].save.x = pty[i].min_x;
 
353
                        pty[i].cur.y = pty[i].save.y = pty[i].max_y - 1;
347
354
                }
348
355
        }
349
356
        resetptyterm(i, 0);
572
579
int w, n, c;
573
580
{
574
581
        resettermattr(-1);
575
 
        regionscroll(n, c, pty[w].cur_x, pty[w].cur_y,
 
582
        regionscroll(n, c, pty[w].cur.x, pty[w].cur.y,
576
583
                pty[w].min_scroll, pty[w].max_scroll);
577
584
        tflush();
578
 
        last_x = pty[w].cur_x;
579
 
        last_y = pty[w].cur_y;
 
585
        last_x = pty[w].cur.x;
 
586
        last_y = pty[w].cur.y;
580
587
}
581
588
 
582
589
static VOID NEAR evallf(w)
583
590
int w;
584
591
{
585
 
        if (pty[w].cur_y < pty[w].max_y
586
 
        && pty[w].cur_y == pty[w].max_scroll)
 
592
        if (pty[w].cur.y < pty[w].max_y
 
593
        && pty[w].cur.y == pty[w].max_scroll)
587
594
                evalscroll(w, C_SCROLLFORW, 1);
588
 
        else reallocate(w, pty[w].cur_x, pty[w].cur_y + 1);
 
595
        else reallocate(w, pty[w].cur.x, pty[w].cur.y + 1);
589
596
}
590
597
 
591
598
static VOID NEAR outputnormal(w, buf, width)
599
606
#endif
600
607
        CONST char *cp;
601
608
 
602
 
        if (pty[w].cur_x + width > pty[w].max_x) {
603
 
                pty[w].cur_x = pty[w].min_x;
 
609
        if (pty[w].cur.x + width > pty[w].max_x) {
 
610
                pty[w].cur.x = pty[w].min_x;
604
611
                evallf(w);
605
612
        }
606
613
 
608
615
        settermattr(w);
609
616
        settermcode(w);
610
617
        cp = buf;
611
 
        if (pty[w].attr & A_INVISIBLE) {
 
618
        if (pty[w].cur.attr & A_INVISIBLE) {
612
619
                memset(buf, ' ', width);
613
620
                buf[width] = '\0';
614
621
        }
622
629
 
623
630
        Xcputs(cp);
624
631
        tflush();
625
 
        pty[w].cur_x += width;
 
632
        pty[w].cur.x += width;
626
633
        last_x += width;
627
634
 
628
 
        if (n_lastcolumn < n_column && pty[w].cur_x >= pty[w].max_x) {
629
 
                pty[w].cur_x = pty[w].min_x;
 
635
        if (n_lastcolumn < n_column && pty[w].cur.x >= pty[w].max_x) {
 
636
                pty[w].cur.x = pty[w].min_x;
630
637
                evallf(w);
631
638
        }
632
639
}
646
653
#endif
647
654
 
648
655
        if ((pty[w].termflags & T_NOAUTOMARGIN)
649
 
        && pty[w].cur_x >= pty[w].max_x - 1)
 
656
        && pty[w].cur.x >= pty[w].max_x - 1)
650
657
                return;
651
658
 
652
659
        i = 0;
716
723
 
717
724
        switch (c) {
718
725
                case '\b':
719
 
                        reallocate(w, pty[w].cur_x - 1, pty[w].cur_y);
 
726
                        reallocate(w, pty[w].cur.x - 1, pty[w].cur.y);
720
727
                        break;
721
728
                case '\t':
722
729
                        for (i = 0; i < pty[w].ntabstop; i++)
723
 
                                if (pty[w].cur_x < pty[w].tabstop[i]) break;
 
730
                                if (pty[w].cur.x < pty[w].tabstop[i]) break;
724
731
                        i = (i < pty[w].ntabstop)
725
732
                                ? pty[w].tabstop[i] : pty[w].max_x - 1;
726
 
                        reallocate(w, i, pty[w].cur_y);
 
733
                        reallocate(w, i, pty[w].cur.y);
727
734
                        break;
728
735
                case '\r':
729
 
                        reallocate(w, pty[w].min_x, pty[w].cur_y);
 
736
                        reallocate(w, pty[w].min_x, pty[w].cur.y);
730
737
                        break;
731
738
                case '\n':
732
739
                case '\v':
759
766
        pty[w].escmode = '\0';
760
767
        switch (c) {
761
768
                case '7':
762
 
                        pty[w].save_x = pty[w].cur_x;
763
 
                        pty[w].save_y = pty[w].cur_y;
 
769
                        memcpy((char *)&(pty[w].save), (char *)&(pty[w].cur),
 
770
                                sizeof(pty[w].save));
764
771
                        break;
765
772
                case '8':
766
 
                        pty[w].cur_x = pty[w].save_x;
767
 
                        pty[w].cur_y = pty[w].save_y;
768
 
                        biasxy(w, &(pty[w].cur_x), &(pty[w].cur_y));
 
773
                        memcpy((char *)&(pty[w].cur), (char *)&(pty[w].save),
 
774
                                sizeof(pty[w].cur));
 
775
                        biasxy(w, &(pty[w].cur.x), &(pty[w].cur.y));
769
776
                        surelocate(w, 1);
770
777
                        tflush();
771
778
                        break;
779
786
                        evallf(w);
780
787
                        break;
781
788
                case 'E':
782
 
                        pty[w].cur_x = pty[w].min_x;
 
789
                        pty[w].cur.x = pty[w].min_x;
783
790
                        evallf(w);
784
791
                        break;
785
792
                case 'H':
786
793
                        if (pty[w].ntabstop >= (u_char)MAXTABSTOP) break;
787
794
                        for (i = 0; i < pty[w].ntabstop; i++)
788
 
                                if (pty[w].cur_x <= pty[w].tabstop[i]) break;
 
795
                                if (pty[w].cur.x <= pty[w].tabstop[i]) break;
789
796
                        if (i >= pty[w].ntabstop)
790
797
                                pty[w].tabstop[(pty[w].ntabstop)++] =
791
 
                                        pty[w].cur_x;
792
 
                        else if (pty[w].cur_x == pty[w].tabstop[i]) break;
 
798
                                        pty[w].cur.x;
 
799
                        else if (pty[w].cur.x == pty[w].tabstop[i]) break;
793
800
                        else {
794
801
                                memmove((char *)&(pty[w].tabstop[i + 1]),
795
802
                                        (char *)&(pty[w].tabstop[i]),
796
803
                                        ((pty[w].ntabstop)++ - i)
797
804
                                                * sizeof(u_short));
798
 
                                pty[w].tabstop[i] = pty[w].cur_x;
 
805
                                pty[w].tabstop[i] = pty[w].cur.x;
799
806
                        }
800
807
                        break;
801
808
                case 'M':
802
 
                        if (pty[w].cur_y >= pty[w].min_y
803
 
                        && pty[w].cur_y == pty[w].min_scroll)
 
809
                        if (pty[w].cur.y >= pty[w].min_y
 
810
                        && pty[w].cur.y == pty[w].min_scroll)
804
811
                                evalscroll(w, L_INSERT, 1);
805
 
                        else reallocate(w, pty[w].cur_x, pty[w].cur_y - 1);
 
812
                        else reallocate(w, pty[w].cur.x, pty[w].cur.y - 1);
806
813
                        break;
807
814
                case 'c':
808
815
                        pty[w].termflags = (u_short)0;
809
816
                        resettermattr(w);
810
817
                        resettermcode(w);
811
818
                        resettabstop(w);
 
819
                        memcpy((char *)&(pty[w].save), (char *)&(pty[w].cur),
 
820
                                sizeof(pty[w].save));
812
821
                        surelocate(w, 1);
813
822
                        tflush();
814
823
                        pty[w].min_scroll = pty[w].min_y;
865
874
                        if (pty[w].escmode != ']') break;
866
875
                        n = pty[w].escparam[0];
867
876
                        if (n <= 0) n = 1;
868
 
                        reallocate(w, pty[w].cur_x, pty[w].cur_y - n);
 
877
                        reallocate(w, pty[w].cur.x, pty[w].cur.y - n);
869
878
                        break;
870
879
                case 'B':
871
880
                        if (pty[w].escmode != ']') break;
872
881
                        n = pty[w].escparam[0];
873
882
                        if (n <= 0) n = 1;
874
 
                        reallocate(w, pty[w].cur_x, pty[w].cur_y + n);
 
883
                        reallocate(w, pty[w].cur.x, pty[w].cur.y + n);
875
884
                        break;
876
885
                case 'C':
877
886
                        if (pty[w].escmode != ']') break;
878
887
                        n = pty[w].escparam[0];
879
888
                        if (n <= 0) n = 1;
880
 
                        reallocate(w, pty[w].cur_x + n, pty[w].cur_y);
 
889
                        reallocate(w, pty[w].cur.x + n, pty[w].cur.y);
881
890
                        break;
882
891
                case 'D':
883
892
                        if (pty[w].escmode != ']') break;
884
893
                        n = pty[w].escparam[0];
885
894
                        if (n <= 0) n = 1;
886
 
                        reallocate(w, pty[w].cur_x - n, pty[w].cur_y);
 
895
                        reallocate(w, pty[w].cur.x - n, pty[w].cur.y);
887
896
                        break;
888
897
                case 'H':
889
898
                case 'f':
892
901
                                ? 0 : pty[w].escparam[1] - 1);
893
902
                        y = pty[w].min_y + (pty[w].escparam[0] - 1);
894
903
                        reallocate(w, x, y);
895
 
                        pty[w].save_x = pty[w].cur_x;
896
 
                        pty[w].save_y = pty[w].cur_y;
897
904
                        break;
898
905
                case 'm':
899
906
                        if (pty[w].escmode != ']') break;
901
908
                        switch (pty[w].escparam[i]) {
902
909
                                case -1:
903
910
                                case 0:
904
 
                                        pty[w].attr = (u_short)0;
905
 
                                        pty[w].fg = pty[w].bg = (short)-1;
 
911
                                        pty[w].cur.attr = (u_short)0;
 
912
                                        pty[w].cur.fg =
 
913
                                        pty[w].cur.bg = (short)-1;
906
914
                                        break;
907
915
                                case 1:
908
 
                                        pty[w].attr |= A_BOLD;
 
916
                                        pty[w].cur.attr |= A_BOLD;
909
917
                                        break;
910
918
                                case 2:
911
 
                                        pty[w].attr |= A_DIM;
 
919
                                        pty[w].cur.attr |= A_DIM;
912
920
                                        break;
913
921
                                case 4:
914
 
                                        pty[w].attr |= A_UNDERLINE;
 
922
                                        pty[w].cur.attr |= A_UNDERLINE;
915
923
                                        break;
916
924
                                case 5:
917
 
                                        pty[w].attr |= A_BLINK;
 
925
                                        pty[w].cur.attr |= A_BLINK;
918
926
                                        break;
919
927
                                case 7:
920
 
                                        pty[w].attr |= A_REVERSE;
 
928
                                        pty[w].cur.attr |= A_REVERSE;
921
929
                                        break;
922
930
                                case 8:
923
 
                                        pty[w].attr |= A_INVISIBLE;
 
931
                                        pty[w].cur.attr |= A_INVISIBLE;
924
932
                                        break;
925
933
                                case 22:
926
 
                                        pty[w].attr &= ~A_BOLD;
 
934
                                        pty[w].cur.attr &= ~A_BOLD;
927
935
                                        break;
928
936
                                case 24:
929
 
                                        pty[w].attr &= ~A_UNDERLINE;
 
937
                                        pty[w].cur.attr &= ~A_UNDERLINE;
930
938
                                        break;
931
939
                                case 25:
932
 
                                        pty[w].attr &= ~A_BLINK;
 
940
                                        pty[w].cur.attr &= ~A_BLINK;
933
941
                                        break;
934
942
                                case 27:
935
 
                                        pty[w].attr &= ~A_REVERSE;
 
943
                                        pty[w].cur.attr &= ~A_REVERSE;
936
944
                                        break;
937
945
                                case 28:
938
 
                                        pty[w].attr &= ~A_INVISIBLE;
 
946
                                        pty[w].cur.attr &= ~A_INVISIBLE;
939
947
                                        break;
940
948
                                case 100:
941
 
                                        pty[w].fg = pty[w].bg = (short)-1;
 
949
                                        pty[w].cur.fg =
 
950
                                        pty[w].cur.bg = (short)-1;
942
951
                                        break;
943
952
                                default:
944
953
                                        n = pty[w].escparam[i];
945
954
                                        if (n >= 30 && n <= 37)
946
 
                                                pty[w].fg = n % 10;
 
955
                                                pty[w].cur.fg = n % 10;
947
956
                                        else if (n >= 40 && n <= 47)
948
 
                                                pty[w].bg = n % 10;
 
957
                                                pty[w].cur.bg = n % 10;
949
958
                                        break;
950
959
                        }
951
960
                        tflush();
952
961
                        break;
953
962
                case 's':
954
963
                        if (pty[w].escmode != ']') break;
955
 
                        pty[w].save_x = pty[w].cur_x;
956
 
                        pty[w].save_y = pty[w].cur_y;
 
964
                        memcpy((char *)&(pty[w].save), (char *)&(pty[w].cur),
 
965
                                sizeof(pty[w].save));
957
966
                        break;
958
967
                case 'u':
959
968
                        if (pty[w].escmode != ']') break;
960
 
                        pty[w].cur_x = pty[w].save_x;
961
 
                        pty[w].cur_y = pty[w].save_y;
962
 
                        biasxy(w, &(pty[w].cur_x), &(pty[w].cur_y));
 
969
                        memcpy((char *)&(pty[w].cur), (char *)&(pty[w].save),
 
970
                                sizeof(pty[w].cur));
 
971
                        biasxy(w, &(pty[w].cur.x), &(pty[w].cur.y));
963
972
                        surelocate(w, 1);
964
973
                        tflush();
965
974
                        break;
984
993
                        switch (pty[w].escparam[0]) {
985
994
                                case -1:
986
995
                                case 0:
987
 
                                        min = pty[w].cur_y;
 
996
                                        min = pty[w].cur.y;
988
997
                                        max = pty[w].max_y;
989
998
                                        break;
990
999
                                case 1:
991
1000
                                        min = pty[w].min_y;
992
 
                                        max = pty[w].cur_y + 1;
 
1001
                                        max = pty[w].cur.y + 1;
993
1002
                                        break;
994
1003
                                case 2:
995
1004
                                        min = pty[w].min_y;
1022
1031
                                        putterm(L_CLEARBOL);
1023
1032
                                        break;
1024
1033
                                case 2:
1025
 
                                        locate(pty[w].min_x, pty[w].cur_y);
 
1034
                                        locate(pty[w].min_x, pty[w].cur.y);
1026
1035
                                        putterm(L_CLEAR);
1027
1036
                                        surelocate(w, 1);
1028
1037
                                        break;
1102
1111
                                        if (pty[w].ntabstop <= (u_char)0)
1103
1112
                                                break;
1104
1113
                                        for (i = 0; i < pty[w].ntabstop; i++)
1105
 
                                                if (pty[w].cur_x
 
1114
                                                if (pty[w].cur.x
1106
1115
                                                <= pty[w].tabstop[i])
1107
1116
                                                        break;
1108
 
                                        if (pty[w].cur_x != pty[w].tabstop[i])
 
1117
                                        if (pty[w].cur.x != pty[w].tabstop[i])
1109
1118
                                                break;
1110
1119
                                        memmove((char *)&(pty[w].tabstop[i]),
1111
1120
                                                (char *)
1131
1140
                                case 6:
1132
1141
                                        i = Xsnprintf(buf, sizeof(buf),
1133
1142
                                                SIZEFMT,
1134
 
                                                pty[w].cur_y
 
1143
                                                pty[w].cur.y
1135
1144
                                                - pty[w].min_y + 1,
1136
 
                                                pty[w].cur_x
 
1145
                                                pty[w].cur.x
1137
1146
                                                - pty[w].min_x + 1);
1138
1147
                                        break;
1139
1148
                                case 99:
1259
1268
                        putterm(L_CLEAR);
1260
1269
                        break;
1261
1270
                case T_NORMAL:
1262
 
                        pty[MAXWINDOWS].attr = (u_short)0;
1263
 
                        pty[MAXWINDOWS].fg = pty[MAXWINDOWS].bg = (short)-1;
 
1271
                        pty[MAXWINDOWS].cur.attr = (u_short)0;
 
1272
                        pty[MAXWINDOWS].cur.fg =
 
1273
                        pty[MAXWINDOWS].cur.bg = (short)-1;
1264
1274
                        break;
1265
1275
                case T_BOLD:
1266
 
                        pty[MAXWINDOWS].attr |= A_BOLD;
 
1276
                        pty[MAXWINDOWS].cur.attr |= A_BOLD;
1267
1277
                        break;
1268
1278
                case T_REVERSE:
1269
 
                        pty[MAXWINDOWS].attr |= A_REVERSE;
 
1279
                        pty[MAXWINDOWS].cur.attr |= A_REVERSE;
1270
1280
                        break;
1271
1281
                case T_DIM:
1272
 
                        pty[MAXWINDOWS].attr |= A_DIM;
 
1282
                        pty[MAXWINDOWS].cur.attr |= A_DIM;
1273
1283
                        break;
1274
1284
                case T_BLINK:
1275
 
                        pty[MAXWINDOWS].attr |= A_BLINK;
 
1285
                        pty[MAXWINDOWS].cur.attr |= A_BLINK;
1276
1286
                        break;
1277
1287
                case T_STANDOUT:
1278
 
                        pty[MAXWINDOWS].attr |= A_STANDOUT;
 
1288
                        pty[MAXWINDOWS].cur.attr |= A_STANDOUT;
1279
1289
                        break;
1280
1290
                case T_UNDERLINE:
1281
 
                        pty[MAXWINDOWS].attr |= A_UNDERLINE;
 
1291
                        pty[MAXWINDOWS].cur.attr |= A_UNDERLINE;
1282
1292
                        break;
1283
1293
                case END_STANDOUT:
1284
 
                        pty[MAXWINDOWS].attr &= ~A_STANDOUT;
 
1294
                        pty[MAXWINDOWS].cur.attr &= ~A_STANDOUT;
1285
1295
                        break;
1286
1296
                case END_UNDERLINE:
1287
 
                        pty[MAXWINDOWS].attr &= ~A_UNDERLINE;
 
1297
                        pty[MAXWINDOWS].cur.attr &= ~A_UNDERLINE;
1288
1298
                        break;
1289
1299
                case L_INSERT:
1290
1300
                case L_DELETE:
1299
1309
                        tflush();
1300
1310
                        break;
1301
1311
                case C_HOME:
1302
 
                        pty[MAXWINDOWS].cur_x =
1303
 
                        pty[MAXWINDOWS].cur_y = (short)0;
 
1312
                        pty[MAXWINDOWS].cur.x =
 
1313
                        pty[MAXWINDOWS].cur.y = (short)0;
1304
1314
                        reallocate(MAXWINDOWS, 0, 0);
1305
1315
                        break;
1306
1316
                case C_RETURN:
1307
1317
                        reallocate(MAXWINDOWS,
1308
 
                                pty[MAXWINDOWS].min_x, pty[MAXWINDOWS].cur_y);
 
1318
                                pty[MAXWINDOWS].min_x, pty[MAXWINDOWS].cur.y);
1309
1319
                        break;
1310
1320
                case C_NEWLINE:
1311
1321
                        while (c--) evallf(MAXWINDOWS);
1313
1323
                case C_UP:
1314
1324
                case C_NUP:
1315
1325
                        reallocate(MAXWINDOWS,
1316
 
                                pty[MAXWINDOWS].cur_x,
1317
 
                                pty[MAXWINDOWS].cur_y - c);
 
1326
                                pty[MAXWINDOWS].cur.x,
 
1327
                                pty[MAXWINDOWS].cur.y - c);
1318
1328
                        break;
1319
1329
                case C_DOWN:
1320
1330
                case C_NDOWN:
1321
1331
                        reallocate(MAXWINDOWS,
1322
 
                                pty[MAXWINDOWS].cur_x,
1323
 
                                pty[MAXWINDOWS].cur_y + c);
 
1332
                                pty[MAXWINDOWS].cur.x,
 
1333
                                pty[MAXWINDOWS].cur.y + c);
1324
1334
                        break;
1325
1335
                case C_RIGHT:
1326
1336
                case C_NRIGHT:
1327
1337
                        reallocate(MAXWINDOWS,
1328
 
                                pty[MAXWINDOWS].cur_x + c,
1329
 
                                pty[MAXWINDOWS].cur_y);
 
1338
                                pty[MAXWINDOWS].cur.x + c,
 
1339
                                pty[MAXWINDOWS].cur.y);
1330
1340
                        break;
1331
1341
                case C_LEFT:
1332
1342
                case C_NLEFT:
1333
1343
                        reallocate(MAXWINDOWS,
1334
 
                                pty[MAXWINDOWS].cur_x - c,
1335
 
                                pty[MAXWINDOWS].cur_y);
 
1344
                                pty[MAXWINDOWS].cur.x - c,
 
1345
                                pty[MAXWINDOWS].cur.y);
1336
1346
                        break;
1337
1347
                default:
1338
1348
                        return(n);
1360
1370
                        settermattr(MAXWINDOWS);
1361
1371
                        settermcode(MAXWINDOWS);
1362
1372
                        i = Xcprintf("%c", w1);
1363
 
                        pty[MAXWINDOWS].cur_x += i;
 
1373
                        pty[MAXWINDOWS].cur.x += i;
1364
1374
                        last_x += i;
1365
1375
                        tflush();
1366
1376
                        break;
1372
1382
                                settermcode(MAXWINDOWS);
1373
1383
                                s[w1] = '\0';
1374
1384
                                i = Xcprintf("%s", s);
1375
 
                                pty[MAXWINDOWS].cur_x += i;
 
1385
                                pty[MAXWINDOWS].cur.x += i;
1376
1386
                                last_x += i;
1377
1387
                                tflush();
1378
1388
                        }
1407
1417
                        reallocate(MAXWINDOWS, w1, w2);
1408
1418
                        for (i = 0; i < MAXWINDOWS; i++) {
1409
1419
                                if (ptylist[i].pid) continue;
1410
 
                                pty[i].cur_x = w1;
1411
 
                                pty[i].cur_y = w2;
1412
 
                                biasxy(i, &(pty[i].cur_x), &(pty[i].cur_y));
 
1420
                                pty[i].cur.x = w1;
 
1421
                                pty[i].cur.y = w2;
 
1422
                                biasxy(i, &(pty[i].cur.x), &(pty[i].cur.y));
1413
1423
                        }
1414
1424
                        break;
1415
1425
                case TE_CPUTNL:
1416
 
                        pty[MAXWINDOWS].cur_x = (short)0;
 
1426
                        pty[MAXWINDOWS].cur.x = (short)0;
1417
1427
                        evallf(MAXWINDOWS);
1418
1428
                        break;
1419
1429
                case TE_CHGCOLOR:
1420
1430
                        if (ptyrecvword(&n) < 0) break;
1421
1431
 
1422
1432
                        if (n) {
1423
 
                                pty[MAXWINDOWS].fg = (w1 == ANSI_BLACK)
 
1433
                                pty[MAXWINDOWS].cur.fg = (w1 == ANSI_BLACK)
1424
1434
                                        ? ANSI_WHITE : ANSI_BLACK;
1425
 
                                pty[MAXWINDOWS].bg = w1;
 
1435
                                pty[MAXWINDOWS].cur.bg = w1;
1426
1436
                        }
1427
1437
                        else {
1428
 
                                pty[MAXWINDOWS].fg = w1;
 
1438
                                pty[MAXWINDOWS].cur.fg = w1;
1429
1439
                        }
1430
1440
                        break;
1431
1441
                case TE_MOVECURSOR:
1444
1454
                        win = w1;
1445
1455
                        if (pid < (p_id_t)0) break;
1446
1456
                        resetptyterm(win, (ptylist[win].pid) ? 0 : 1);
1447
 
                        biasxy(win, &(pty[win].cur_x), &(pty[win].cur_y));
 
1457
                        biasxy(win, &(pty[win].cur.x), &(pty[win].cur.y));
1448
1458
                        ptylist[win].pid = pid;
1449
1459
                        surelocate(win, 1);
1450
1460
                        tflush();
1589
1599
                if (incode != outcode) cnv++;
1590
1600
                key.len = (u_char)2;
1591
1601
                key.str = buf;
1592
 
                buf[0] = C_EKANA;
 
1602
                buf[0] = (char)C_EKANA;
1593
1603
                buf[1] = (key.code & 0xff);
1594
1604
        }
1595
1605
#else   /* !DEP_KCONV */
1597
1607
        else if (isekana2(key.code)) {
1598
1608
                key.len = (u_char)2;
1599
1609
                key.str = buf;
1600
 
                buf[0] = C_EKANA;
 
1610
                buf[0] = (char)C_EKANA;
1601
1611
                buf[1] = (key.code & 0xff);
1602
1612
        }
1603
1613
# endif