sys/dev/video/pcvt/i386/pcvt_vtf.c

   1 /*
   2  * Copyright (c) 1999 Hellmuth Michaelis
   3  *
   4  * Copyright (c) 1992, 1995 Hellmuth Michaelis and Joerg Wunsch.
   5  *
   6  * Copyright (c) 1992, 1993 Brian Dunford-Shore.
   7  *
   8  * All rights reserved.
   9  *
  10  * This code is derived from software contributed to Berkeley by
  11  * William Jolitz and Don Ahn.
  12  *
  13  * Redistribution and use in source and binary forms, with or without
  14  * modification, are permitted provided that the following conditions
  15  * are met:
  16  * 1. Redistributions of source code must retain the above copyright
  17  *    notice, this list of conditions and the following disclaimer.
  18  * 2. Redistributions in binary form must reproduce the above copyright
  19  *    notice, this list of conditions and the following disclaimer in the
  20  *    documentation and/or other materials provided with the distribution.
  21  * 3. All advertising materials mentioning features or use of this software
  22  *    must display the following acknowledgement:
  23  *      This product includes software developed by Hellmuth Michaelis,
  24  *      Brian Dunford-Shore and Joerg Wunsch.
  25  * 4. The name authors may not be used to endorse or promote products
  26  *    derived from this software without specific prior written permission.
  27  *
  28  * THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS OR
  29  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  30  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  31  * IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY DIRECT, INDIRECT,
  32  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  33  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  34  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  35  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  36  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  37  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  38  */
  39
  40 /*---------------------------------------------------------------------------*
  41  *
  42  *      pcvt_vtf.c      VT220 Terminal Emulator Functions
  43  *      -------------------------------------------------
  44  *
  45  *      Last Edit-Date: [Mon Dec 27 14:13:33 1999]
  46  *
  47  * $FreeBSD: src/sys/i386/isa/pcvt/pcvt_vtf.c,v 1.11 1999/12/30 16:17:11 hm Exp $
  48  * $DragonFly: src/sys/dev/video/pcvt/i386/Attic/pcvt_vtf.c,v 1.5 2003/08/07 21:17:16 dillon Exp $
  49  *
  50  *---------------------------------------------------------------------------*/
  51
  52 #include "use_vt.h"
  53 #if NVT > 0
  54
  55 #define PCVT_INCLUDE_VT_SELATTR /* get inline function from pcvt_hdr.h */
  56
  57 #include "pcvt_hdr.h"   /* global include */
  58 #include "pcvt_tbl.h"   /* character set conversion tables */
  59
  60 static void clear_dld ( struct video_state *svsp );
  61 static void init_dld ( struct video_state *svsp );
  62 static void init_udk ( struct video_state *svsp );
  63 static void respond ( struct video_state *svsp );
  64 static void roll_down ( struct video_state *svsp, int n );
  65 static void selective_erase ( struct video_state *svsp, u_short *pcrtat,
  66                               int length );
  67 static void swcsp ( struct video_state *svsp, u_short *ctp );
  68
  69 /*---------------------------------------------------------------------------*
  70  *      DECSTBM - set top and bottom margins
  71  *---------------------------------------------------------------------------*/
  72 void
  73 vt_stbm(struct video_state *svsp)
  74 {
  75         /* both 0 => scrolling region = entire screen */
  76
  77         if((svsp->parms[0] == 0) && (svsp->parms[1] == 0))
  78         {
  79                 svsp->cur_offset = 0;
  80                 svsp->scrr_beg = 0;
  81                 svsp->scrr_len = svsp->screen_rows;
  82                 svsp->scrr_end = svsp->scrr_len - 1;
  83                 svsp->col = 0;
  84                 return;
  85         }
  86
  87         if(svsp->parms[1] <= svsp->parms[0])
  88                 return;
  89
  90         /* range parm 1 */
  91
  92         if(svsp->parms[0] < 1)
  93                 svsp->parms[0] = 1;
  94         else if(svsp->parms[0] > svsp->screen_rows-1)
  95                 svsp->parms[0] = svsp->screen_rows-1;
  96
  97         /* range parm 2 */
  98
  99         if(svsp->parms[1] < 2)
 100                 svsp->parms[1] = 2;
 101         else if(svsp->parms[1] > svsp->screen_rows)
 102                 svsp->parms[1] = svsp->screen_rows;
 103
 104         svsp->scrr_beg = svsp->parms[0]-1;      /* begin of scrolling region */
 105         svsp->scrr_len = svsp->parms[1] - svsp->parms[0] + 1; /* no of lines */
 106         svsp->scrr_end = svsp->parms[1]-1;
 107
 108         /* cursor to first pos */
 109         if(svsp->m_om)
 110                 svsp->cur_offset = svsp->scrr_beg * svsp->maxcol;
 111         else
 112                 svsp->cur_offset = 0;
 113
 114         svsp->col = 0;
 115 }
 116
 117 /*---------------------------------------------------------------------------*
 118  *      SGR - set graphic rendition
 119  *---------------------------------------------------------------------------*/
 120 void
 121 vt_sgr(struct video_state *svsp)
 122 {
 123         int i = 0;
 124         u_short setcolor = 0;
 125         char colortouched = 0;
 126
 127         do
 128         {
 129                 switch(svsp->parms[i++])
 130                 {
 131                         case 0:         /* reset to normal attributes */
 132                                 svsp->vtsgr = VT_NORMAL;
 133                                 break;
 134
 135                         case 1:         /* bold */
 136                                 svsp->vtsgr |= VT_BOLD;
 137                                 break;
 138
 139                         case 4:         /* underline */
 140                                 svsp->vtsgr |= VT_UNDER;
 141                                 break;
 142
 143                         case 5:         /* blinking */
 144                                 svsp->vtsgr |= VT_BLINK;
 145                                 break;
 146
 147                         case 7:         /* reverse */
 148                                 svsp->vtsgr |= VT_INVERSE;
 149                                 break;
 150
 151                         case 22:        /* not bold */
 152                                 svsp->vtsgr &= ~VT_BOLD;
 153                                 break;
 154
 155                         case 24:        /* not underlined */
 156                                 svsp->vtsgr &= ~VT_UNDER;
 157                                 break;
 158
 159                         case 25:        /* not blinking */
 160                                 svsp->vtsgr &= ~VT_BLINK;
 161                                 break;
 162
 163                         case 27:        /* not reverse */
 164                                 svsp->vtsgr &= ~VT_INVERSE;
 165                                 break;
 166
 167                         case 30:        /* foreground colors */
 168                         case 31:
 169                         case 32:
 170                         case 33:
 171                         case 34:
 172                         case 35:
 173                         case 36:
 174                         case 37:
 175                                 if(color)
 176                                 {
 177                                  colortouched = 1;
 178                                  setcolor |= ((fgansitopc[(svsp->parms[i-1]-30) & 7]) << 8);
 179                                 }
 180                                 break;
 181
 182                         case 40:        /* background colors */
 183                         case 41:
 184                         case 42:
 185                         case 43:
 186                         case 44:
 187                         case 45:
 188                         case 46:
 189                         case 47:
 190                                 if(color)
 191                                 {
 192                                  colortouched = 1;
 193                                  setcolor |= ((bgansitopc[(svsp->parms[i-1]-40) & 7]) << 8);
 194                                 }
 195                                 break;
 196                 }
 197         }
 198         while(i <= svsp->parmi);
 199         if(color)
 200         {
 201                 if(colortouched)
 202                         svsp->c_attr = setcolor;
 203                 else
 204                         svsp->c_attr = ((sgr_tab_color[svsp->vtsgr]) << 8);
 205         }
 206         else
 207         {
 208                 if(adaptor_type == MDA_ADAPTOR)
 209                         svsp->c_attr = ((sgr_tab_imono[svsp->vtsgr]) << 8);
 210                 else
 211                         svsp->c_attr = ((sgr_tab_mono[svsp->vtsgr]) << 8);
 212         }
 213 }
 214
 215 /*---------------------------------------------------------------------------*
 216  *      CUU - cursor up
 217  *---------------------------------------------------------------------------*/
 218 void
 219 vt_cuu(struct video_state *svsp)
 220 {
 221         int p = svsp->parms[0];
 222
 223         if (p <= 0)                             /* parameter min */
 224                 p = 1;
 225
 226         p = min(p, svsp->row - svsp->scrr_beg);
 227
 228         if (p <= 0)
 229                 return;
 230
 231         svsp->cur_offset -= (svsp->maxcol * p);
 232 }
 233
 234 /*---------------------------------------------------------------------------*
 235  *      CUD - cursor down
 236  *---------------------------------------------------------------------------*/
 237 void
 238 vt_cud(struct video_state *svsp)
 239 {
 240         int p = svsp->parms[0];
 241
 242         if (p <= 0)
 243                 p = 1;
 244
 245         p = min(p, svsp->scrr_end - svsp->row);
 246
 247         if (p <= 0)
 248                 return;
 249
 250         svsp->cur_offset += (svsp->maxcol * p);
 251 }
 252
 253 /*---------------------------------------------------------------------------*
 254  *      CUF - cursor forward
 255  *---------------------------------------------------------------------------*/
 256 void
 257 vt_cuf(struct video_state *svsp)
 258 {
 259         int p = svsp->parms[0];
 260
 261         if(svsp->col == ((svsp->maxcol)-1))     /* already at right margin */
 262                 return;
 263
 264         if(p <= 0)                              /* parameter min = 1 */
 265                 p = 1;
 266         else if(p > ((svsp->maxcol)-1))         /* parameter max = 79 */
 267                 p = ((svsp->maxcol)-1);
 268
 269         if((svsp->col + p) > ((svsp->maxcol)-1))/* not more than right margin */
 270                 p = ((svsp->maxcol)-1) - svsp->col;
 271
 272         svsp->cur_offset += p;
 273         svsp->col += p;
 274 }
 275
 276 /*---------------------------------------------------------------------------*
 277  *      CUB - cursor backward
 278  *---------------------------------------------------------------------------*/
 279 void
 280 vt_cub(struct video_state *svsp)
 281 {
 282         int p = svsp->parms[0];
 283
 284         if(svsp->col == 0)                      /* already at left margin ? */
 285                 return;
 286
 287         if(p <= 0)                              /* parameter min = 1 */
 288                 p = 1;
 289         else if(p > ((svsp->maxcol)-1))         /* parameter max = 79 */
 290                 p = ((svsp->maxcol)-1);
 291
 292         if((svsp->col - p) <= 0)                /* not more than left margin */
 293                 p = svsp->col;
 294
 295         svsp->cur_offset -= p;
 296         svsp->col -= p;
 297 }
 298
 299 /*---------------------------------------------------------------------------*
 300  *      ED - erase in display
 301  *---------------------------------------------------------------------------*/
 302 void
 303 vt_clreos(struct video_state *svsp)
 304 {
 305         switch(svsp->parms[0])
 306         {
 307                 case 0:
 308                         fillw(user_attr | ' ', svsp->Crtat + svsp->cur_offset,
 309                                 svsp->Crtat +
 310                                 (svsp->maxcol * svsp->screen_rows) -
 311                                 (svsp->Crtat + svsp->cur_offset));
 312                         break;
 313
 314                 case 1:
 315                         fillw(user_attr | ' ', svsp->Crtat,
 316                                 svsp->Crtat + svsp->cur_offset -
 317                                 svsp->Crtat + 1 );
 318                         break;
 319
 320                 case 2:
 321                         fillw(user_attr | ' ', svsp->Crtat,
 322                                 svsp->maxcol * svsp->screen_rows);
 323                         break;
 324         }
 325 }
 326
 327 /*---------------------------------------------------------------------------*
 328  *      EL - erase in line
 329  *---------------------------------------------------------------------------*/
 330 void
 331 vt_clreol(struct video_state *svsp)
 332 {
 333         switch(svsp->parms[0])
 334         {
 335                 case 0:
 336                         fillw(user_attr | ' ',
 337                                 svsp->Crtat + svsp->cur_offset,
 338                                 svsp->maxcol-svsp->col);
 339                         break;
 340
 341                 case 1:
 342                         fillw(user_attr | ' ',
 343                                 svsp->Crtat + svsp->cur_offset - svsp->col,
 344                                 svsp->col + 1);
 345                         break;
 346
 347                 case 2:
 348                         fillw(user_attr | ' ',
 349                                 svsp->Crtat + svsp->cur_offset - svsp->col,
 350                                 svsp->maxcol);
 351                         break;
 352         }
 353 }
 354
 355 /*---------------------------------------------------------------------------*
 356  *      CUP - cursor position / HVP - horizontal & vertical position
 357  *---------------------------------------------------------------------------*/
 358 void
 359 vt_curadr(struct video_state *svsp)
 360 {
 361         if(svsp->m_om)  /* relative to scrolling region */
 362         {
 363                 if((svsp->parms[0] == 0) && (svsp->parms[1] == 0))
 364                 {
 365                         svsp->cur_offset = svsp->scrr_beg * svsp->maxcol;
 366                         svsp->col = 0;
 367                         svsp->abs_write = 0;
 368                         return;
 369                 }
 370
 371                 if(svsp->parms[0] <= 0)
 372                         svsp->parms[0] = 1;
 373                 else if(svsp->parms[0] > svsp->scrr_len)
 374                         svsp->parms[0] = svsp->scrr_len;
 375
 376                 if(svsp->parms[1] <= 0 )
 377                         svsp->parms[1] = 1;
 378                 if(svsp->parms[1] > svsp->maxcol)
 379                         svsp->parms[1] = svsp->maxcol;
 380
 381                 svsp->cur_offset = (svsp->scrr_beg * svsp->maxcol) +
 382                                    ((svsp->parms[0] - 1) * svsp->maxcol) +
 383                                    svsp->parms[1] - 1;
 384                 svsp->col = svsp->parms[1] - 1;
 385                 svsp->abs_write = 0;
 386         }
 387         else    /* relative to screen start */
 388         {
 389                 if((svsp->parms[0] == 0) && (svsp->parms[1] == 0))
 390                 {
 391                         svsp->cur_offset = 0;
 392                         svsp->col = 0;
 393                         svsp->abs_write = 0;
 394                         return;
 395                 }
 396
 397                 if(svsp->parms[0] <= 0)
 398                         svsp->parms[0] = 1;
 399                 else if(svsp->parms[0] > svsp->screen_rows)
 400                         svsp->parms[0] = svsp->screen_rows;
 401
 402                 if(svsp->parms[1] <= 0 )
 403                         svsp->parms[1] = 1;
 404                 if(svsp->parms[1] > svsp->maxcol)       /* col */
 405                         svsp->parms[1] = svsp->maxcol;
 406
 407                 svsp->cur_offset = (((svsp->parms[0]-1)*svsp->maxcol) +
 408                                     (svsp->parms[1]-1));
 409                 svsp->col = svsp->parms[1]-1;
 410
 411                 if (svsp->cur_offset >=
 412                         ((svsp->scrr_beg + svsp->scrr_len + 1) * svsp->maxcol))
 413
 414                         svsp->abs_write = 1;
 415                 else
 416                         svsp->abs_write = 0;
 417         }
 418 }
 419
 420 /*---------------------------------------------------------------------------*
 421  *      RIS - reset to initial state (hard emulator runtime reset)
 422  *---------------------------------------------------------------------------*/
 423 void
 424 vt_ris(struct video_state *svsp)
 425 {
 426         fillw(user_attr | ' ', svsp->Crtat, svsp->maxcol * svsp->screen_rows);
 427         svsp->cur_offset = 0;           /* cursor upper left corner */
 428         svsp->col = 0;
 429         svsp->row = 0;
 430         svsp->lnm = 0;                  /* CR only */
 431         clear_dld(svsp);                /* clear download charset */
 432         vt_clearudk(svsp);              /* clear user defined keys */
 433         svsp->selchar = 0;              /* selective attribute off */
 434         vt_str(svsp);                   /* and soft terminal reset */
 435 }
 436
 437 /*---------------------------------------------------------------------------*
 438  *      DECSTR - soft terminal reset (SOFT emulator runtime reset)
 439  *---------------------------------------------------------------------------*/
 440 void
 441 vt_str(struct video_state *svsp)
 442 {
 443         int i;
 444
 445         clr_parms(svsp);                        /* escape parameter init */
 446         svsp->state = STATE_INIT;               /* initial state */
 447
 448         svsp->dis_fnc = 0;                      /* display functions reset */
 449
 450         svsp->sc_flag = 0;                      /* save cursor position */
 451         svsp->transparent = 0;                  /* enable control code processing */
 452
 453         for(i = 0; i < MAXTAB; i++)             /* setup tabstops */
 454         {
 455                 if(!(i % 8))
 456                         svsp->tab_stops[i] = 1;
 457                 else
 458                         svsp->tab_stops[i] = 0;
 459         }
 460
 461         svsp->irm = 0;                          /* replace mode */
 462         svsp->m_om = 0;                         /* origin mode */
 463         svsp->m_awm = 1;                        /* auto wrap mode */
 464
 465 #if PCVT_INHIBIT_NUMLOCK
 466         svsp->num_lock = 0;                     /* keypad application mode */
 467 #else
 468         svsp->num_lock = 1;                     /* keypad numeric mode */
 469 #endif
 470
 471         svsp->scroll_lock = 0;                  /* reset keyboard modes */
 472         svsp->caps_lock = 0;
 473
 474         svsp->ckm = 1;                          /* cursor key mode = "normal" ... */
 475         svsp->scrr_beg = 0;                     /* start of scrolling region */
 476         svsp->scrr_len = svsp->screen_rows;     /* no. of lines in scrolling region */
 477         svsp->abs_write = 0;                    /* scrr is complete screen */
 478         svsp->scrr_end = svsp->scrr_len - 1;
 479
 480         if(adaptor_type == EGA_ADAPTOR || adaptor_type == VGA_ADAPTOR)
 481         {
 482                 svsp->G0 = cse_ascii;           /* G0 = ascii   */
 483                 svsp->G1 = cse_ascii;           /* G1 = ascii   */
 484                 svsp->G2 = cse_supplemental;    /* G2 = supplemental */
 485                 svsp->G3 = cse_supplemental;    /* G3 = supplemental */
 486                 svsp->GL = &svsp->G0;           /* GL = G0 */
 487                 svsp->GR = &svsp->G2;           /* GR = G2 */
 488         }
 489         else
 490         {
 491                 svsp->G0 = csd_ascii;           /* G0 = ascii   */
 492                 svsp->G1 = csd_ascii;           /* G1 = ascii   */
 493                 svsp->G2 = csd_supplemental;    /* G2 = supplemental */
 494                 svsp->G3 = csd_supplemental;    /* G3 = supplemental */
 495                 svsp->GL = &svsp->G0;           /* GL = G0 */
 496                 svsp->GR = &svsp->G2;           /* GR = G2 */
 497         }
 498
 499         svsp->vtsgr = VT_NORMAL;                /* no attributes */
 500         svsp->c_attr = user_attr;               /* reset sgr to normal */
 501
 502         svsp->selchar = 0;                      /* selective attribute off */
 503         vt_initsel(svsp);
 504
 505         init_ufkl(svsp);                        /* init user fkey labels */
 506         init_sfkl(svsp);                        /* init system fkey labels */
 507
 508         update_led();                           /* update keyboard LED's */
 509 }
 510
 511 /*---------------------------------------------------------------------------*
 512  *      RI - reverse index, move cursor up
 513  *---------------------------------------------------------------------------*/
 514 void
 515 vt_ri(struct video_state *svsp)
 516 {
 517         if(svsp->cur_offset >= ((svsp->scrr_beg * svsp->maxcol) + svsp->maxcol))
 518                 svsp->cur_offset -= svsp->maxcol;
 519         else
 520                 roll_down(svsp, 1);
 521 }
 522
 523 /*---------------------------------------------------------------------------*
 524  *      IND - index, move cursor down
 525  *---------------------------------------------------------------------------*/
 526 void
 527 vt_ind(struct video_state *svsp)
 528 {
 529         if(svsp->cur_offset < (svsp->scrr_end * svsp->maxcol))
 530                 svsp->cur_offset += svsp->maxcol;
 531         else
 532                 roll_up(svsp, 1);
 533 }
 534
 535 /*---------------------------------------------------------------------------*
 536  *      NEL - next line, first pos of next line
 537  *---------------------------------------------------------------------------*/
 538 void
 539 vt_nel(struct video_state *svsp)
 540 {
 541         if(svsp->cur_offset < (svsp->scrr_end * svsp->maxcol))
 542         {
 543                 svsp->cur_offset += (svsp->maxcol-svsp->col);
 544                 svsp->col = 0;
 545         }
 546         else
 547         {
 548                 roll_up(svsp, 1);
 549                 svsp->cur_offset -= svsp->col;
 550                 svsp->col = 0;
 551         }
 552 }
 553
 554 /*---------------------------------------------------------------------------*
 555  *      set dec private modes, esc [ ? x h
 556  *---------------------------------------------------------------------------*/
 557 void
 558 vt_set_dec_priv_qm(struct video_state *svsp)
 559 {
 560         switch(svsp->parms[0])
 561         {
 562                 case 0:         /* error, ignored */
 563                 case 1:         /* CKM - cursor key mode */
 564                         svsp->ckm = 1;
 565                         break;
 566
 567                 case 2:         /* ANM - ansi/vt52 mode */
 568                         break;
 569
 570                 case 3:         /* COLM - column mode */
 571                         vt_col(svsp, SCR_COL132);
 572                         break;
 573
 574                 case 4:         /* SCLM - scrolling mode */
 575                 case 5:         /* SCNM - screen mode */
 576                         break;
 577
 578                 case 6:         /* OM - origin mode */
 579                         svsp->m_om = 1;
 580                         break;
 581
 582                 case 7:         /* AWM - auto wrap mode */
 583                         svsp->m_awm = 1;
 584                         swritefkl(7,(u_char *)"AUTOWRAPENABLE *",svsp);
 585                         break;
 586
 587                 case 8:         /* ARM - auto repeat mode */
 588                         kbrepflag = 1;
 589                         break;
 590
 591                 case 9:         /* INLM - interlace mode */
 592                 case 10:        /* EDM - edit mode */
 593                 case 11:        /* LTM - line transmit mode */
 594                 case 12:        /* */
 595                 case 13:        /* SCFDM - space compression / field delimiting */
 596                 case 14:        /* TEM - transmit execution mode */
 597                 case 15:        /* */
 598                 case 16:        /* EKEM - edit key execution mode */
 599                         break;
 600
 601                 case 25:        /* TCEM - text cursor enable mode */
 602                         if(vsp == svsp)
 603                                 sw_cursor(1);   /* cursor on */
 604                         svsp->cursor_on = 1;
 605                         break;
 606
 607                 case 42:        /* NRCM - 7bit NRC characters */
 608                         break;
 609         }
 610 }
 611
 612 /*---------------------------------------------------------------------------*
 613  *      reset dec private modes, esc [ ? x l
 614  *---------------------------------------------------------------------------*/
 615 void
 616 vt_reset_dec_priv_qm(struct video_state *svsp)
 617 {
 618         switch(svsp->parms[0])
 619         {
 620                 case 0:         /* error, ignored */
 621                 case 1:         /* CKM - cursor key mode */
 622                         svsp->ckm = 0;
 623                         break;
 624
 625                 case 2:         /* ANM - ansi/vt52 mode */
 626                         break;
 627
 628                 case 3:         /* COLM - column mode */
 629                         vt_col(svsp, SCR_COL80);
 630                         break;
 631
 632                 case 4:         /* SCLM - scrolling mode */
 633                 case 5:         /* SCNM - screen mode */
 634                         break;
 635
 636                 case 6:         /* OM - origin mode */
 637                         svsp->m_om = 0;
 638                         break;
 639
 640                 case 7:         /* AWM - auto wrap mode */
 641                         svsp->m_awm = 0;
 642                         swritefkl(7,(u_char *)"AUTOWRAPENABLE  ",svsp);
 643                         break;
 644
 645                 case 8:         /* ARM - auto repeat mode */
 646                         kbrepflag = 0;
 647                         break;
 648
 649                 case 9:         /* INLM - interlace mode */
 650                 case 10:        /* EDM - edit mode */
 651                 case 11:        /* LTM - line transmit mode */
 652                 case 12:        /* */
 653                 case 13:        /* SCFDM - space compression / field delimiting */
 654                 case 14:        /* TEM - transmit execution mode */
 655                 case 15:        /* */
 656                 case 16:        /* EKEM - edit key execution mode */
 657                         break;
 658
 659                 case 25:        /* TCEM - text cursor enable mode */
 660                         if(vsp == svsp)
 661                                 sw_cursor(0);   /* cursor off */
 662                         svsp->cursor_on = 0;
 663                         break;
 664
 665                 case 42:        /* NRCM - 7bit NRC characters */
 666                         break;
 667         }
 668 }
 669
 670 /*---------------------------------------------------------------------------*
 671  *      set ansi modes, esc [ x
 672  *---------------------------------------------------------------------------*/
 673 void
 674 vt_set_ansi(struct video_state *svsp)
 675 {
 676         switch(svsp->parms[0])
 677         {
 678                 case 0:         /* error, ignored */
 679                 case 1:         /* GATM - guarded area transfer mode */
 680                 case 2:         /* KAM - keyboard action mode */
 681                 case 3:         /* CRM - Control Representation mode */
 682                         break;
 683
 684                 case 4:         /* IRM - insert replacement mode */
 685                         svsp->irm = 1; /* Insert mode */
 686                         break;
 687
 688                 case 5:         /* SRTM - status report transfer mode */
 689                 case 6:         /* ERM - erasue mode */
 690                 case 7:         /* VEM - vertical editing mode */
 691                 case 10:        /* HEM - horizontal editing mode */
 692                 case 11:        /* PUM - position unit mode */
 693                 case 12:        /* SRM - send-receive mode */
 694                 case 13:        /* FEAM - format effector action mode */
 695                 case 14:        /* FETM - format effector transfer mode */
 696                 case 15:        /* MATM - multiple area transfer mode */
 697                 case 16:        /* TTM - transfer termination */
 698                 case 17:        /* SATM - selected area transfer mode */
 699                 case 18:        /* TSM - tabulation stop mode */
 700                 case 19:        /* EBM - editing boundary mode */
 701                         break;
 702
 703                 case 20:        /* LNM - line feed / newline mode */
 704                         svsp->lnm = 1;
 705                         break;
 706         }
 707 }
 708
 709 /*---------------------------------------------------------------------------*
 710  *      reset ansi modes, esc [ x
 711  *---------------------------------------------------------------------------*/
 712 void
 713 vt_reset_ansi(struct video_state *svsp)
 714 {
 715         switch(svsp->parms[0])
 716         {
 717                 case 0:         /* error, ignored */
 718                 case 1:         /* GATM - guarded area transfer mode */
 719                 case 2:         /* KAM - keyboard action mode */
 720                 case 3:         /* CRM - Control Representation mode */
 721                         break;
 722
 723                 case 4:         /* IRM - insert replacement mode */
 724                         svsp->irm = 0;  /* Replace mode */
 725                         break;
 726
 727                 case 5:         /* SRTM - status report transfer mode */
 728                 case 6:         /* ERM - erasue mode */
 729                 case 7:         /* VEM - vertical editing mode */
 730                 case 10:        /* HEM - horizontal editing mode */
 731                 case 11:        /* PUM - position unit mode */
 732                 case 12:        /* SRM - send-receive mode */
 733                 case 13:        /* FEAM - format effector action mode */
 734                 case 14:        /* FETM - format effector transfer mode */
 735                 case 15:        /* MATM - multiple area transfer mode */
 736                 case 16:        /* TTM - transfer termination */
 737                 case 17:        /* SATM - selected area transfer mode */
 738                 case 18:        /* TSM - tabulation stop mode */
 739                 case 19:        /* EBM - editing boundary mode */
 740                         break;
 741
 742                 case 20:        /* LNM - line feed / newline mode */
 743                         svsp->lnm = 0;
 744                         break;
 745         }
 746 }
 747
 748 /*---------------------------------------------------------------------------*
 749  *      clear tab stop(s)
 750  *---------------------------------------------------------------------------*/
 751 void
 752 vt_clrtab(struct video_state *svsp)
 753 {
 754         int i;
 755
 756         if(svsp->parms[0] == 0)
 757                 svsp->tab_stops[svsp->col] = 0;
 758         else if(svsp->parms[0] == 3)
 759         {
 760                 for(i=0; i<MAXTAB; i++)
 761                         svsp->tab_stops[i] = 0;
 762         }
 763 }
 764
 765 /*---------------------------------------------------------------------------*
 766  *      DECSC - save cursor & attributes
 767  *---------------------------------------------------------------------------*/
 768 void
 769 vt_sc(struct video_state *svsp)
 770 {
 771         svsp->sc_flag = 1;
 772         svsp->sc_row = svsp->row;
 773         svsp->sc_col = svsp->col;
 774         svsp->sc_cur_offset = svsp->cur_offset;
 775         svsp->sc_attr = svsp->c_attr;
 776         svsp->sc_awm = svsp->m_awm;
 777         svsp->sc_om = svsp->m_om;
 778         svsp->sc_G0 = svsp->G0;
 779         svsp->sc_G1 = svsp->G1;
 780         svsp->sc_G2 = svsp->G2;
 781         svsp->sc_G3 = svsp->G3;
 782         svsp->sc_GL = svsp->GL;
 783         svsp->sc_GR = svsp->GR;
 784         svsp->sc_sel = svsp->selchar;
 785         svsp->sc_vtsgr = svsp->vtsgr;
 786 }
 787
 788 /*---------------------------------------------------------------------------*
 789  *      DECRC - restore cursor & attributes
 790  *---------------------------------------------------------------------------*/
 791 void
 792 vt_rc(struct video_state *svsp)
 793 {
 794         if(svsp->sc_flag == 1)
 795         {
 796                 svsp->sc_flag = 0;
 797                 svsp->row = svsp->sc_row;
 798                 svsp->col = svsp->sc_col;
 799                 svsp->cur_offset = svsp->sc_cur_offset;
 800                 svsp->c_attr = svsp->sc_attr;
 801                 svsp->m_awm = svsp->sc_awm;
 802                 svsp->m_om = svsp->sc_om;
 803                 svsp->G0 = svsp->sc_G0;
 804                 svsp->G1 = svsp->sc_G1;
 805                 svsp->G2 = svsp->sc_G2;
 806                 svsp->G3 = svsp->sc_G3;
 807                 svsp->GL = svsp->sc_GL;
 808                 svsp->GR = svsp->sc_GR;
 809                 svsp->selchar = svsp->sc_sel;
 810                 svsp->vtsgr = svsp->sc_vtsgr;
 811         }
 812 }
 813
 814 /*---------------------------------------------------------------------------*
 815  *      designate a character set as G0, G1, G2 or G3 for 94/96 char sets
 816  *---------------------------------------------------------------------------*/
 817 void
 818 vt_designate(struct video_state *svsp)
 819 {
 820         u_short *ctp = NULL;
 821         u_char ch;
 822
 823         if(svsp->whichi == 1)
 824                 ch = svsp->which[0];
 825         else
 826         {
 827                 int i;
 828
 829                 if(svsp->dld_id[0] == '\0')
 830                         return;
 831
 832                 if(!(((adaptor_type == EGA_ADAPTOR) ||
 833                      (adaptor_type == VGA_ADAPTOR)) &&
 834                      (vgacs[svsp->vga_charset].secondloaded)))
 835                 {
 836                         return;
 837                 }
 838
 839                 for(i = (svsp->whichi)-1; i >= 0; i--)
 840                 {
 841                          if(svsp->which[i] != svsp->dld_id[i])
 842                                 return;
 843                 }
 844 #ifdef HAVECSE_DOWNLOADABLE
 845                 ctp = cse_downloadable;
 846                 swcsp(svsp, ctp);
 847 #endif
 848                 return;
 849         }
 850
 851         if(((adaptor_type == EGA_ADAPTOR) || (adaptor_type == VGA_ADAPTOR)) &&
 852            (vgacs[svsp->vga_charset].secondloaded))
 853         {
 854                 if((ch == svsp->dld_id[0]) && (svsp->dld_id[1] == '\0'))
 855                 {
 856 #ifdef HAVECSE_DOWNLOADABLE
 857                         ctp = cse_downloadable;
 858                         swcsp(svsp, ctp);
 859 #endif
 860                         return;
 861                 }
 862
 863                 switch(ch)
 864                 {
 865                         case 'A': /* British or ISO-Latin-1 */
 866                                 switch(svsp->state)
 867                                 {
 868                                         case STATE_BROPN: /* designate G0 */
 869                                         case STATE_BRCLO: /* designate G1 */
 870                                         case STATE_STAR:  /* designate G2 */
 871                                         case STATE_PLUS:  /* designate G3 */
 872 #ifdef HAVECSE_BRITISH
 873                                                 ctp = cse_british;
 874 #endif
 875                                                 break;
 876
 877                                         case STATE_MINUS: /* designate G1 (96)*/
 878                                         case STATE_DOT:   /* designate G2 (96)*/
 879                                         case STATE_SLASH: /* designate G3 (96)*/
 880 #ifdef HAVECSE_ISOLATIN
 881                                                 ctp = cse_isolatin;
 882 #endif
 883                                                 break;
 884                                 }
 885                                 break;
 886
 887                         case 'B': /* USASCII */
 888 #ifdef HAVECSE_ASCII
 889                                 ctp = cse_ascii;
 890 #endif
 891                                 break;
 892
 893                         case 'C': /* Finnish */
 894                         case '5': /* Finnish */
 895 #ifdef HAVECSE_FINNISH
 896                                 ctp = cse_finnish;
 897 #endif
 898                                 break;
 899
 900                         case 'E': /* Norwegian/Danish */
 901                         case '6': /* Norwegian/Danish */
 902 #ifdef HAVECSE_NORWEGIANDANISH
 903                                 ctp = cse_norwegiandanish;
 904 #endif
 905                                 break;
 906
 907                         case 'H': /* Swedish */
 908                         case '7': /* Swedish */
 909 #ifdef HAVECSE_SWEDISH
 910                                 ctp = cse_swedish;
 911 #endif
 912                                 break;
 913
 914                         case 'K': /* German */
 915 #ifdef HAVECSE_GERMAN
 916                                 ctp = cse_german;
 917 #endif
 918                                 break;
 919
 920                         case 'Q': /* French Canadien */
 921 #ifdef HAVECSE_FRENCHCANADA
 922                                 ctp = cse_frenchcanada;
 923 #endif
 924                                 break;
 925
 926                         case 'R': /* French */
 927 #ifdef HAVECSE_FRENCH
 928                                 ctp = cse_french;
 929 #endif
 930                                 break;
 931
 932                         case 'Y': /* Italian */
 933 #ifdef HAVECSE_ITALIAN
 934                                 ctp = cse_italian;
 935 #endif
 936                                 break;
 937
 938                         case 'Z': /* Spanish */
 939 #ifdef HAVECSE_SPANISH
 940                                 ctp = cse_spanish;
 941 #endif
 942                                 break;
 943
 944                         case '0': /* special graphics */
 945 #ifdef HAVECSE_SPECIAL
 946                                 ctp = cse_special;
 947 #endif
 948                                 break;
 949
 950                         case '1': /* alternate ROM */
 951 #ifdef HAVECSE_ALTERNATEROM1
 952                                 ctp = cse_alternaterom1;
 953 #endif
 954                                 break;
 955
 956                         case '2': /* alt ROM, spec graphics */
 957 #ifdef HAVECSE_ALTERNATEROM2
 958                                 ctp = cse_alternaterom2;
 959 #endif
 960                                 break;
 961
 962                         case '3': /* HP Roman 8, upper 128 chars*/
 963 #ifdef HAVECSE_ROMAN8
 964                                 ctp = cse_roman8;
 965 #endif
 966                                 break;
 967
 968                         case '4': /* Dutch */
 969 #ifdef HAVECSE_DUTCH
 970                                 ctp = cse_dutch;
 971 #endif
 972                                 break;
 973
 974                         case '<': /* DEC Supplemental */
 975 #ifdef HAVECSE_SUPPLEMENTAL
 976                                 ctp = cse_supplemental;
 977 #endif
 978                                 break;
 979
 980                         case '=': /* Swiss */
 981 #ifdef HAVECSE_SWISS
 982                                 ctp = cse_swiss;
 983 #endif
 984                                 break;
 985
 986                         case '>': /* DEC Technical */
 987 #ifdef HAVECSE_TECHNICAL
 988                                 ctp = cse_technical;
 989 #endif
 990                                 break;
 991
 992                         default:
 993                                 break;
 994                 }
 995         }
 996         else
 997         {
 998                 switch(ch)
 999                 {
1000                         case 'A': /* British or ISO-Latin-1 */
1001                                 switch(svsp->state)
1002                                 {
1003                                         case STATE_BROPN: /* designate G0 */
1004                                         case STATE_BRCLO: /* designate G1 */
1005                                         case STATE_STAR:  /* designate G2 */
1006                                         case STATE_PLUS:  /* designate G3 */
1007 #ifdef HAVECSD_BRITISH
1008                                                 ctp = csd_british;
1009 #endif
1010                                                 break;
1011
1012                                         case STATE_MINUS: /* designate G1 (96)*/
1013                                         case STATE_DOT:   /* designate G2 (96)*/
1014                                         case STATE_SLASH: /* designate G3 (96)*/
1015 #ifdef HAVECSD_ISOLATIN
1016                                                 ctp = csd_isolatin;
1017 #endif
1018                                                 break;
1019                                 }
1020                                 break;
1021
1022                         case 'B': /* USASCII */
1023 #ifdef HAVECSD_ASCII
1024                                 ctp = csd_ascii;
1025 #endif
1026                                 break;
1027
1028                         case 'C': /* Finnish */
1029                         case '5': /* Finnish */
1030 #ifdef HAVECSD_FINNISH
1031                                 ctp = csd_finnish;
1032 #endif
1033                                 break;
1034
1035                         case 'E': /* Norwegian/Danish */
1036                         case '6': /* Norwegian/Danish */
1037 #ifdef HAVECSD_NORWEGIANDANISH
1038                                 ctp = csd_norwegiandanish;
1039 #endif
1040                                 break;
1041
1042                         case 'H': /* Swedish */
1043                         case '7': /* Swedish */
1044 #ifdef HAVECSD_SWEDISH
1045                                 ctp = csd_swedish;
1046 #endif
1047                                 break;
1048
1049                         case 'K': /* German */
1050 #ifdef HAVECSD_GERMAN
1051                                 ctp = csd_german;
1052 #endif
1053                                 break;
1054
1055                         case 'Q': /* French Canadien */
1056 #ifdef HAVECSD_FRENCHCANADA
1057                                 ctp = csd_frenchcanada;
1058 #endif
1059                                 break;
1060
1061                         case 'R': /* French */
1062 #ifdef HAVECSD_FRENCH
1063                                 ctp = csd_french;
1064 #endif
1065                                 break;
1066
1067                         case 'Y': /* Italian */
1068 #ifdef HAVECSD_ITALIAN
1069                                 ctp = csd_italian;
1070 #endif
1071                                 break;
1072
1073                         case 'Z': /* Spanish */
1074 #ifdef HAVECSD_SPANISH
1075                                 ctp = csd_spanish;
1076 #endif
1077                                 break;
1078
1079                         case '0': /* special graphics */
1080 #ifdef HAVECSD_SPECIAL
1081                                 ctp = csd_special;
1082 #endif
1083                                 break;
1084
1085                         case '1': /* alternate ROM */
1086 #ifdef HAVECSD_ALTERNATEROM1
1087                                 ctp = csd_alternaterom1;
1088 #endif
1089                                 break;
1090
1091                         case '2': /* alt ROM, spec graphics */
1092 #ifdef HAVECSD_ALTERNATEROM2
1093                                 ctp = csd_alternaterom2;
1094 #endif
1095                                 break;
1096
1097                         case '3': /* HP Roman 8, upper 128 chars*/
1098 #ifdef HAVECSD_ROMAN8
1099                                 ctp = csd_roman8;
1100 #endif
1101                                 break;
1102
1103                         case '4': /* Dutch */
1104 #ifdef HAVECSD_DUTCH
1105                                 ctp = csd_dutch;
1106 #endif
1107                                 break;
1108
1109                         case '<': /* DEC Supplemental */
1110 #ifdef HAVECSD_SUPPLEMENTAL
1111                                 ctp = csd_supplemental;
1112 #endif
1113                                 break;
1114
1115                         case '=': /* Swiss */
1116 #ifdef HAVECSD_SWISS
1117                                 ctp = csd_swiss;
1118 #endif
1119                                 break;
1120
1121                         case '>': /* DEC Technical */
1122 #ifdef HAVECSD_TECHNICAL
1123                                 ctp = csd_technical;
1124 #endif
1125                                 break;
1126
1127                         default:
1128                                 break;
1129                 }
1130         }
1131         swcsp(svsp, ctp);
1132 }
1133
1134 /*---------------------------------------------------------------------------*
1135  *      device attributes
1136  *---------------------------------------------------------------------------*/
1137 void
1138 vt_da(struct video_state *svsp)
1139 {
1140         static u_char *response = (u_char *)DA_VT220;
1141
1142         svsp->report_chars = response;
1143         svsp->report_count = 18;
1144         respond(svsp);
1145 }
1146
1147 /*---------------------------------------------------------------------------*
1148  *      screen alignment display
1149  *---------------------------------------------------------------------------*/
1150 void
1151 vt_aln(struct video_state *svsp)
1152 {
1153         int i;
1154
1155         svsp->cur_offset = 0;
1156         svsp->col = 0;
1157
1158         for(i=0; i < (svsp->screen_rows*svsp->maxcol); i++)
1159         {
1160                 *(svsp->Crtat + svsp->cur_offset) = user_attr | 'E';
1161                 vt_selattr(svsp);
1162                 svsp->cur_offset++;
1163                 svsp->col++;
1164         }
1165
1166         svsp->cur_offset = 0;   /* reset everything ! */
1167         svsp->col = 0;
1168         svsp->row = 0;
1169 }
1170
1171 /*---------------------------------------------------------------------------*
1172  *      request terminal parameters
1173  *---------------------------------------------------------------------------*/
1174 void
1175 vt_reqtparm(struct video_state *svsp)
1176 {
1177         static u_char *answr = (u_char *)"\033[3;1;1;120;120;1;0x";
1178
1179         svsp->report_chars = answr;
1180         svsp->report_count = 20;
1181         respond(svsp);
1182 }
1183
1184 /*---------------------------------------------------------------------------*
1185  *      invoke selftest
1186  *---------------------------------------------------------------------------*/
1187 void
1188 vt_tst(struct video_state *svsp)
1189 {
1190         clear_dld(svsp);
1191 }
1192
1193 /*---------------------------------------------------------------------------*
1194  *      device status reports
1195  *---------------------------------------------------------------------------*/
1196 void
1197 vt_dsr(struct video_state *svsp)
1198 {
1199         static u_char *answr = (u_char *)"\033[0n";
1200         static u_char *panswr = (u_char *)"\033[?13n"; /* Printer Unattached */
1201         static u_char *udkanswr = (u_char *)"\033[?21n"; /* UDK Locked */
1202         static u_char *langanswr = (u_char *)"\033[?27;1n"; /* North American*/
1203         static u_char buffer[16];
1204         int i = 0;
1205
1206         switch(svsp->parms[0])
1207         {
1208                 case 5:         /* return status */
1209                         svsp->report_chars = answr;
1210                         svsp->report_count = 4;
1211                         respond(svsp);
1212                         break;
1213
1214                 case 6:         /* return cursor position */
1215                         buffer[i++] = 0x1b;
1216                         buffer[i++] = '[';
1217                         if((svsp->row+1) > 10)
1218                                 buffer[i++] = ((svsp->row+1) / 10) + '0';
1219                         buffer[i++] = ((svsp->row+1) % 10) + '0';
1220                         buffer[i++] = ';';
1221                         if((svsp->col+1) > 10)
1222                                 buffer[i++] = ((svsp->col+1) / 10) + '0';
1223                         buffer[i++] = ((svsp->col+1) % 10) + '0';
1224                         buffer[i++] = 'R';
1225                         buffer[i++] = '\0';
1226
1227                         svsp->report_chars = buffer;
1228                         svsp->report_count = i;
1229                         respond(svsp);
1230                         break;
1231
1232                 case 15:        /* return printer status */
1233                         svsp->report_chars = panswr;
1234                         svsp->report_count = 6;
1235                         respond(svsp);
1236                         break;
1237
1238                 case 25:        /* return udk status */
1239                         svsp->report_chars = udkanswr;
1240                         svsp->report_count = 6;
1241                         respond(svsp);
1242                         break;
1243
1244                 case 26:        /* return language status */
1245                         svsp->report_chars = langanswr;
1246                         svsp->report_count = 8;
1247                         respond(svsp);
1248                         break;
1249
1250                 default:        /* nothing else valid */
1251                         break;
1252         }
1253 }
1254
1255 /*---------------------------------------------------------------------------*
1256  *      IL - insert line
1257  *---------------------------------------------------------------------------*/
1258 void
1259 vt_il(struct video_state *svsp)
1260 {
1261         int p = svsp->parms[0];
1262
1263         if((svsp->row >= svsp->scrr_beg) && (svsp->row <= svsp->scrr_end))
1264         {
1265                 if(p <= 0)
1266                         p = 1;
1267                 else if(p > svsp->scrr_end - svsp->row)
1268                         p = svsp->scrr_end - svsp->row;
1269
1270                 svsp->cur_offset -= svsp->col;
1271                 svsp->col = 0;
1272                 if(svsp->row == svsp->scrr_beg)
1273                         roll_down(svsp, p);
1274                 else
1275                 {
1276                     bcopy(svsp->Crtat + svsp->cur_offset,
1277                           svsp->Crtat + svsp->cur_offset + (p * svsp->maxcol),
1278                           svsp->maxcol * (svsp->scrr_end-svsp->row+1-p) * CHR );
1279
1280                     fillw(user_attr | ' ',
1281                           svsp->Crtat + svsp->cur_offset,
1282                           p * svsp->maxcol);
1283                 }
1284         }
1285 }
1286
1287 /*---------------------------------------------------------------------------*
1288  *      ICH - insert character
1289  *---------------------------------------------------------------------------*/
1290 void
1291 vt_ic(struct video_state *svsp)
1292 {
1293         int p = svsp->parms[0];
1294
1295         if(p <= 0)
1296                 p = 1;
1297         else if(p > svsp->maxcol-svsp->col)
1298                 p = svsp->maxcol-svsp->col;
1299
1300         while(p--)
1301         {
1302                 bcopy((svsp->Crtat + svsp->cur_offset),
1303                       (svsp->Crtat + svsp->cur_offset) + 1,
1304                       (((svsp->maxcol)-1)-svsp->col) * CHR);
1305
1306                 *(svsp->Crtat + svsp->cur_offset) = user_attr | ' ';
1307                 vt_selattr(svsp);
1308         }
1309 }
1310
1311 /*---------------------------------------------------------------------------*
1312  *      DL - delete line
1313  *---------------------------------------------------------------------------*/
1314 void
1315 vt_dl(struct video_state *svsp)
1316 {
1317         int p = svsp->parms[0];
1318
1319         if((svsp->row >= svsp->scrr_beg) && (svsp->row <= svsp->scrr_end))
1320         {
1321                 if(p <= 0)
1322                         p = 1;
1323                 else if(p > svsp->scrr_end - svsp->row)
1324                         p = svsp->scrr_end - svsp->row;
1325
1326                 svsp->cur_offset -= svsp->col;
1327                 svsp->col = 0;
1328
1329                 if(svsp->row == svsp->scrr_beg)
1330                         roll_up(svsp, p);
1331                 else
1332                 {
1333                     bcopy(svsp->Crtat + svsp->cur_offset + (p * svsp->maxcol),
1334                           svsp->Crtat + svsp->cur_offset,
1335                           svsp->maxcol * (svsp->scrr_end-svsp->row+1-p) * CHR );
1336
1337                     fillw(user_attr | ' ',
1338                           svsp->Crtat + ((svsp->scrr_end-p+1) * svsp->maxcol),
1339                           p * svsp->maxcol);
1340                 }
1341         }
1342 }
1343
1344 /*---------------------------------------------------------------------------*
1345  *      DCH - delete character
1346  *---------------------------------------------------------------------------*/
1347 void
1348 vt_dch(struct video_state *svsp)
1349 {
1350         int p = svsp->parms[0];
1351
1352         if(p <= 0)
1353                 p = 1;
1354         else if(p > svsp->maxcol-svsp->col)
1355                 p = svsp->maxcol-svsp->col;
1356
1357         while(p--)
1358         {
1359                 bcopy((svsp->Crtat + svsp->cur_offset)+1,
1360                       (svsp->Crtat + svsp->cur_offset),
1361                       (((svsp->maxcol)-1) - svsp->col)* CHR );
1362
1363                 *((svsp->Crtat + svsp->cur_offset) +
1364                         ((svsp->maxcol)-1)-svsp->col) = user_attr | ' ';
1365         }
1366 }
1367
1368 /*---------------------------------------------------------------------------*
1369  *      scroll up
1370  *---------------------------------------------------------------------------*/
1371 void
1372 vt_su(struct video_state *svsp)
1373 {
1374         int p = svsp->parms[0];
1375
1376         if(p <= 0)
1377                 p = 1;
1378         else if(p > svsp->screen_rows-1)
1379                 p = svsp->screen_rows-1;
1380
1381         roll_up(svsp, p);
1382 }
1383
1384 /*---------------------------------------------------------------------------*
1385  *      scroll down
1386  *---------------------------------------------------------------------------*/
1387 void
1388 vt_sd(struct video_state *svsp)
1389 {
1390         int p = svsp->parms[0];
1391
1392         if(p <= 0)
1393                 p = 1;
1394         else if(p > svsp->screen_rows-1)
1395                 p = svsp->screen_rows-1;
1396
1397         roll_down(svsp, p);
1398 }
1399
1400 /*---------------------------------------------------------------------------*
1401  *      ECH - erase character
1402  *---------------------------------------------------------------------------*/
1403 void
1404 vt_ech(struct video_state *svsp)
1405 {
1406         int p = svsp->parms[0];
1407
1408         if(p <= 0)
1409                 p = 1;
1410         else if(p > svsp->maxcol-svsp->col)
1411                 p = svsp->maxcol-svsp->col;
1412
1413         fillw(user_attr | ' ', (svsp->Crtat + svsp->cur_offset), p);
1414 }
1415
1416 /*---------------------------------------------------------------------------*
1417  *      media copy      (NO PRINTER AVAILABLE IN KERNEL ...)
1418  *---------------------------------------------------------------------------*/
1419 void
1420 vt_mc(struct video_state *svsp)
1421 {
1422 }
1423
1424 /*---------------------------------------------------------------------------*
1425  *      Device Control String State Machine Entry for:
1426  *
1427  *      DECUDK - user-defined keys      and
1428  *      DECDLD - downloadable charset
1429  *
1430  *---------------------------------------------------------------------------*/
1431 void
1432 vt_dcsentry(U_char ch, struct video_state *svsp)
1433 {
1434         switch(svsp->dcs_state)
1435         {
1436                 case DCS_INIT:
1437                         switch(ch)
1438                         {
1439                                 case '0':
1440                                 case '1':
1441                                 case '2':
1442                                 case '3':
1443                                 case '4':
1444                                 case '5':
1445                                 case '6':
1446                                 case '7':
1447                                 case '8':
1448                                 case '9':       /* parameters */
1449                                         svsp->parms[svsp->parmi] *= 10;
1450                                         svsp->parms[svsp->parmi] += (ch -'0');
1451                                         break;
1452
1453                                 case ';':       /* next parameter */
1454                                         svsp->parmi =
1455                                                 (svsp->parmi+1 < MAXPARMS) ?
1456                                                 svsp->parmi+1 : svsp->parmi;
1457                                         break;
1458
1459                                 case '|':       /* DECUDK */
1460                                         svsp->transparent = 1;
1461                                         init_udk(svsp);
1462                                         svsp->dcs_state = DCS_AND_UDK;
1463                                         break;
1464
1465                                 case '{':       /* DECDLD */
1466                                         svsp->transparent = 1;
1467                                         init_dld(svsp);
1468                                         svsp->dcs_state = DCS_DLD_DSCS;
1469                                         break;
1470
1471                                 default:         /* failsafe */
1472                                         svsp->transparent = 0;
1473                                         svsp->state = STATE_INIT;
1474                                         svsp->dcs_state = DCS_INIT;
1475                                         break;
1476                         }
1477                         break;
1478
1479                 case DCS_AND_UDK:        /* DCS ... | */
1480                         switch(ch)
1481                         {
1482                                 case '0':
1483                                 case '1':
1484                                 case '2':
1485                                 case '3':
1486                                 case '4':
1487                                 case '5':
1488                                 case '6':
1489                                 case '7':
1490                                 case '8':
1491                                 case '9':       /* fkey number */
1492                                         svsp->udk_fnckey *= 10;
1493                                         svsp->udk_fnckey += (ch -'0');
1494                                         break;
1495
1496                                 case '/':       /* Key */
1497                                         svsp->dcs_state = DCS_UDK_DEF;
1498                                         break;
1499
1500                                 case 0x1b:       /* ESC */
1501                                         svsp->dcs_state = DCS_UDK_ESC;
1502                                         break;
1503
1504                                 default:
1505                                         svsp->transparent = 0;
1506                                         svsp->state = STATE_INIT;
1507                                         svsp->dcs_state = DCS_INIT;
1508                                         break;
1509                         }
1510                         break;
1511
1512                 case DCS_UDK_DEF:        /* DCS ... | fnckey / */
1513                         switch(ch)
1514                         {
1515                                 case '0':
1516                                 case '1':
1517                                 case '2':
1518                                 case '3':
1519                                 case '4':
1520                                 case '5':
1521                                 case '6':
1522                                 case '7':
1523                                 case '8':
1524                                 case '9':
1525                                         if(svsp->udk_deflow)    /* low nibble */
1526                                         {
1527                                                 svsp->udk_def[svsp->udk_defi] |= (ch -'0');
1528                                                 svsp->udk_deflow = 0;
1529                                                 svsp->udk_defi = (svsp->udk_defi+1 >= MAXUDKDEF) ?
1530                                                 svsp->udk_defi : svsp->udk_defi+1;
1531                                         }
1532                                         else                    /* high nibble */
1533                                         {
1534                                                 svsp->udk_def[svsp->udk_defi] = ((ch -'0') << 4);
1535                                                 svsp->udk_deflow = 1;
1536                                         }
1537                                         break;
1538
1539                                 case 'a':
1540                                 case 'b':
1541                                 case 'c':
1542                                 case 'd':
1543                                 case 'e':
1544                                 case 'f':
1545                                         if(svsp->udk_deflow)    /* low nibble */
1546                                         {
1547                                                 svsp->udk_def[svsp->udk_defi] |= (ch - 'a' + 10);
1548                                                 svsp->udk_deflow = 0;
1549                                                 svsp->udk_defi = (svsp->udk_defi+1 >= MAXUDKDEF) ?
1550                                                 svsp->udk_defi : svsp->udk_defi+1;
1551                                         }
1552                                         else                    /* high nibble */
1553                                         {
1554                                                 svsp->udk_def[svsp->udk_defi] = ((ch - 'a' + 10) << 4);
1555                                                 svsp->udk_deflow = 1;
1556                                         }
1557                                         break;
1558
1559
1560
1561                                 case 'A':
1562                                 case 'B':
1563                                 case 'C':
1564                                 case 'D':
1565                                 case 'E':
1566                                 case 'F':
1567                                         if(svsp->udk_deflow)    /* low nibble */
1568                                         {
1569                                                 svsp->udk_def[svsp->udk_defi] |= (ch - 'A' + 10);
1570                                                 svsp->udk_deflow = 0;
1571                                                 svsp->udk_defi = (svsp->udk_defi+1 >= MAXUDKDEF) ?
1572                                                 svsp->udk_defi : svsp->udk_defi+1;
1573                                         }
1574                                         else                    /* high nibble */
1575                                         {
1576                                                 svsp->udk_def[svsp->udk_defi] = ((ch - 'A' + 10) << 4);
1577                                                 svsp->udk_deflow = 1;
1578                                         }
1579                                         break;
1580
1581                                 case ';':       /* next function key */
1582                                         vt_udk(svsp);
1583                                         svsp->dcs_state = DCS_AND_UDK;
1584                                         break;
1585
1586                                 case 0x1b:       /* ESC */
1587                                         svsp->dcs_state = DCS_UDK_ESC;
1588                                         break;
1589
1590                                 default:
1591                                         svsp->transparent = 0;
1592                                         svsp->state = STATE_INIT;
1593                                         svsp->dcs_state = DCS_INIT;
1594                                         break;
1595                         }
1596                         break;
1597
1598                 case DCS_UDK_ESC:        /* DCS ... | fkey/def ... ESC */
1599                         switch(ch)
1600                         {
1601                                 case '\\':      /* ST */
1602                                         vt_udk(svsp);
1603                                         svsp->transparent = 0;
1604                                         svsp->state = STATE_INIT;
1605                                         svsp->dcs_state = DCS_INIT;
1606                                         break;
1607
1608                                 default:
1609                                         svsp->transparent = 0;
1610                                         svsp->state = STATE_INIT;
1611                                         svsp->dcs_state = DCS_INIT;
1612                                         break;
1613                         }
1614                         break;
1615
1616
1617                 case DCS_DLD_DSCS:       /* got DCS ... { */
1618                         if(ch >= ' ' && ch <= '/')      /* intermediates ... */
1619                         {
1620                                 svsp->dld_dscs[svsp->dld_dscsi] = ch;
1621                                 svsp->dld_id[svsp->dld_dscsi] = ch;
1622                                 if(svsp->dld_dscsi >= DSCS_LENGTH)
1623                                 {
1624                                         svsp->transparent = 0;
1625                                         svsp->state = STATE_INIT;
1626                                         svsp->dcs_state = DCS_INIT;
1627                                         svsp->dld_id[0] = '\0';
1628                                 }
1629                                 else
1630                                 {
1631                                         svsp->dld_dscsi++;
1632                                 }
1633                         }
1634                         else if(ch >= '0' && ch <= '~') /* final .... */
1635                         {
1636                                 svsp->dld_dscs[svsp->dld_dscsi] = ch;
1637                                 svsp->dld_id[svsp->dld_dscsi++] = ch;
1638                                 svsp->dld_id[svsp->dld_dscsi] = '\0';
1639                                 svsp->dcs_state = DCS_DLD_DEF;
1640                         }
1641                         else
1642                         {
1643                                 svsp->transparent = 0;
1644                                 svsp->state = STATE_INIT;
1645                                 svsp->dcs_state = DCS_INIT;
1646                                 svsp->dld_id[0] = '\0';
1647                         }
1648                         break;
1649
1650                 case DCS_DLD_DEF:        /* DCS ... { dscs */
1651                         switch(ch)
1652                         {
1653                                 case 0x1b:       /* ESC */
1654                                         svsp->dcs_state = DCS_DLD_ESC;
1655                                         break;
1656
1657                                 case '/':        /* sixel upper / lower divider */
1658                                         svsp->dld_sixel_lower = 1;
1659                                         break;
1660
1661                                 case ';':        /* character divider */
1662                                         vt_dld(svsp);
1663                                         svsp->parms[1]++;       /* next char */
1664                                         break;
1665
1666                                 default:
1667                                         if (svsp->dld_sixel_lower)
1668                                         {
1669                                                 if(ch >= '?' && ch <= '~')
1670                                                         svsp->sixel.lower[svsp->dld_sixelli] = ch - '?';
1671                                                 svsp->dld_sixelli =
1672                                                  (svsp->dld_sixelli+1 < MAXSIXEL) ?
1673                                                  svsp->dld_sixelli+1 : svsp->dld_sixelli;
1674                                         }
1675                                         else
1676                                         {
1677                                                 if(ch >= '?' && ch <= '~')
1678                                                         svsp->sixel.upper[svsp->dld_sixelui] = ch - '?';
1679                                                 svsp->dld_sixelui =
1680                                                  (svsp->dld_sixelui+1 < MAXSIXEL) ?
1681                                                  svsp->dld_sixelui+1 : svsp->dld_sixelui;
1682                                         }
1683                                         break;
1684                         }
1685                         break;
1686
1687                 case DCS_DLD_ESC:        /* DCS ... { dscs ... / ... ESC */
1688                         switch(ch)
1689                         {
1690                                 case '\\':      /* String Terminator ST */
1691                                         vt_dld(svsp);
1692                                         svsp->transparent = 0;
1693                                         svsp->state = STATE_INIT;
1694                                         svsp->dcs_state = DCS_INIT;
1695                                         break;
1696
1697                                 default:
1698                                         svsp->transparent = 0;
1699                                         svsp->state = STATE_INIT;
1700                                         svsp->dcs_state = DCS_INIT;
1701                                         svsp->dld_id[0] = '\0';
1702                                         break;
1703                         }
1704                         break;
1705
1706                 default:
1707                         svsp->transparent = 0;
1708                         svsp->state = STATE_INIT;
1709                         svsp->dcs_state = DCS_INIT;
1710                         break;
1711         }
1712 }
1713
1714 /*---------------------------------------------------------------------------*
1715  *      User Defineable Keys
1716  *---------------------------------------------------------------------------*/
1717 void
1718 vt_udk(struct video_state *svsp)
1719 {
1720         int key, start, max, i;
1721         int usedff = 0;
1722
1723         if(svsp->parms[0] != 1)         /* clear all ? */
1724         {
1725                 vt_clearudk(svsp);
1726                 svsp->parms[0] = 1;
1727         }
1728
1729         if(svsp->udk_fnckey < 17 || svsp->udk_fnckey > 34)
1730         {
1731                 init_udk(svsp);
1732                 return;
1733         }
1734
1735         key = svsp->udk_fnckey - 17;    /* index into table */
1736
1737         if(svsp->ukt.length[key] == 0)                  /* never used ? */
1738         {
1739                 if(svsp->udkff < MAXUDKDEF-2)           /* space available ? */
1740                 {
1741                         start = svsp->udkff;            /* next sequential */
1742                         max = MAXUDKDEF - svsp->udkff;  /* space available */
1743                         svsp->ukt.first[key] = start;   /* start entry */
1744                         usedff = 1;                     /* flag to update later */
1745                 }
1746                 else                                    /* no space */
1747                 {
1748                         init_udk(svsp);
1749                         return;
1750                 }
1751         }
1752         else                                            /* in use, redefine */
1753         {
1754                 start = svsp->ukt.first[key];           /* start entry */
1755                 max = svsp->ukt.length[key];            /* space available */
1756         }
1757
1758         if(max < 2)                             /* hmmm .. */
1759         {
1760                 init_udk(svsp);
1761                 return;
1762         }
1763
1764         max--;          /* adjust for tailing '\0' */
1765
1766         for(i = 0; i < max && i < svsp->udk_defi; i++)
1767                 svsp->udkbuf[start++] = svsp->udk_def[i];
1768
1769         svsp->udkbuf[start] = '\0';     /* make it a string, see pcvt_kbd.c */
1770         svsp->ukt.length[key] = i+1;    /* count for tailing '\0' */
1771         if(usedff)
1772                 svsp->udkff += (i+2);   /* new start location */
1773
1774         init_udk(svsp);
1775 }
1776
1777 /*---------------------------------------------------------------------------*
1778  *      clear all User Defineable Keys
1779  *---------------------------------------------------------------------------*/
1780 void
1781 vt_clearudk(struct video_state *svsp)
1782 {
1783         int i;
1784
1785         for(i = 0; i < MAXUDKEYS; i++)
1786         {
1787                 svsp->ukt.first[i] = 0;
1788                 svsp->ukt.length[i] = 0;
1789         }
1790         svsp->udkff = 0;
1791 }
1792
1793 /*---------------------------------------------------------------------------*
1794  *      Down line LoaDable Fonts
1795  *---------------------------------------------------------------------------*/
1796 void
1797 vt_dld(struct video_state *svsp)
1798 {
1799         unsigned char vgacharset;
1800         unsigned char vgachar[16];
1801         unsigned char vgacharb[16];
1802
1803         if(vgacs[svsp->vga_charset].secondloaded)
1804                 vgacharset = vgacs[svsp->vga_charset].secondloaded;
1805         else
1806                 return;
1807
1808         svsp->parms[1] = (svsp->parms[1] < 1) ? 1 :
1809                 ((svsp->parms[1] > 0x7E) ? 0x7E : svsp->parms[1]);
1810
1811         if(svsp->parms[2] != 1)   /* Erase all characters ? */
1812         {
1813                 clear_dld(svsp);
1814                 svsp->parms[2] = 1;   /* Only erase all characters once per sequence */
1815         }
1816
1817         sixel_vga(&(svsp->sixel),vgachar);
1818
1819         switch(vgacs[vgacharset].char_scanlines & 0x1F)
1820         {
1821                 case 7:
1822                         vga10_vga8(vgachar,vgacharb);
1823                         break;
1824
1825                 case 9:
1826                 default:
1827                         vga10_vga10(vgachar,vgacharb);
1828                         break;
1829
1830                 case 13:
1831                         vga10_vga14(vgachar,vgacharb);
1832                         break;
1833
1834                 case 15:
1835                         vga10_vga16(vgachar,vgacharb);
1836                         break;
1837         }
1838
1839         loadchar(vgacharset, svsp->parms[1] + 0xA0, 16, vgacharb);
1840
1841         init_dld(svsp);
1842 }
1843
1844 /*---------------------------------------------------------------------------*
1845  *      select character attributes
1846  *---------------------------------------------------------------------------*/
1847 void
1848 vt_sca(struct video_state *svsp)
1849 {
1850         switch(svsp->parms[0])
1851         {
1852                 case 1:
1853                         svsp->selchar = 1;
1854                         break;
1855                 case 0:
1856                 case 2:
1857                 default:
1858                         svsp->selchar = 0;
1859                         break;
1860         }
1861 }
1862
1863 /*---------------------------------------------------------------------------*
1864  *      initalize selective attribute bit array
1865  *---------------------------------------------------------------------------*/
1866 void
1867 vt_initsel(struct video_state *svsp)
1868 {
1869         int i;
1870
1871         for(i = 0;i < MAXDECSCA;i++)
1872                 svsp->decsca[i] = 0;
1873 }
1874
1875 /*---------------------------------------------------------------------------*
1876  *      DECSEL - selective erase in line
1877  *---------------------------------------------------------------------------*/
1878 void
1879 vt_sel(struct video_state *svsp)
1880 {
1881         switch(svsp->parms[0])
1882         {
1883                 case 0:
1884                         selective_erase(svsp, (svsp->Crtat + svsp->cur_offset),
1885                                          svsp->maxcol-svsp->col);
1886                         break;
1887
1888                 case 1:
1889                         selective_erase(svsp, (svsp->Crtat + svsp->cur_offset)-
1890                                         svsp->col, svsp->col + 1);
1891                         break;
1892
1893                 case 2:
1894                         selective_erase(svsp, (svsp->Crtat + svsp->cur_offset)-
1895                                         svsp->col, svsp->maxcol);
1896                         break;
1897         }
1898 }
1899
1900 /*---------------------------------------------------------------------------*
1901  *      DECSED - selective erase in display
1902  *---------------------------------------------------------------------------*/
1903 void
1904 vt_sed(struct video_state *svsp)
1905 {
1906         switch(svsp->parms[0])
1907         {
1908                 case 0:
1909                         selective_erase(svsp, (svsp->Crtat + svsp->cur_offset),
1910                               svsp->Crtat + (svsp->maxcol * svsp->screen_rows) -
1911                               (svsp->Crtat + svsp->cur_offset));
1912                         break;
1913
1914                 case 1:
1915                         selective_erase(svsp, svsp->Crtat,
1916                            (svsp->Crtat + svsp->cur_offset) - svsp->Crtat + 1 );
1917                         break;
1918
1919                 case 2:
1920                         selective_erase(svsp, svsp->Crtat,
1921                                 svsp->maxcol * svsp->screen_rows);
1922                         break;
1923         }
1924 }
1925
1926 /*---------------------------------------------------------------------------*
1927  *      scroll screen n lines up
1928  *---------------------------------------------------------------------------*/
1929 void
1930 roll_up(struct video_state *svsp, int n)
1931 {
1932
1933 #if (PCVT_NOFASTSCROLL==0)
1934
1935         if(svsp->scrr_beg == 0 &&       /* if scroll region is whole screen */
1936            svsp->scrr_len == svsp->screen_rows &&
1937            (svsp != vsp ||              /* and either running in memory */
1938             (svsp->screen_rows == svsp->screen_rowsize && /* or no fkeys */
1939              adaptor_type != MDA_ADAPTOR)))     /* and not on MDA/Hercules */
1940         {
1941                 u_short *Memory =
1942
1943 #if PCVT_USL_VT_COMPAT
1944                     (vsp != svsp || (vsp->vt_status & VT_GRAFX)) ?
1945 #else
1946                     (vsp != svsp) ?
1947 #endif
1948
1949                                 svsp->Memory : Crtat;
1950
1951                 if(svsp->Crtat > (Memory + (svsp->screen_rows - n) *
1952                                         svsp->maxcol))
1953                 {
1954                         bcopy(svsp->Crtat + svsp->maxcol * n, Memory,
1955                               svsp->maxcol * (svsp->screen_rows - n) * CHR);
1956
1957                         svsp->Crtat = Memory;
1958                 }
1959                 else
1960                 {
1961                         svsp->Crtat += n * svsp->maxcol;
1962                 }
1963
1964 #if PCVT_USL_VT_COMPAT
1965                 if(vsp == svsp && !(vsp->vt_status & VT_GRAFX))
1966 #else
1967                 if(vsp == svsp)
1968 #endif
1969
1970                 {
1971                         outb(addr_6845, CRTC_STARTADRH);
1972                         outb(addr_6845+1, (svsp->Crtat - Crtat) >> 8);
1973                         outb(addr_6845, CRTC_STARTADRL);
1974                         outb(addr_6845+1, (svsp->Crtat - Crtat));
1975                 }
1976         }
1977         else
1978 #endif
1979         {
1980                 bcopy(  svsp->Crtat + ((svsp->scrr_beg + n) * svsp->maxcol),
1981                         svsp->Crtat + (svsp->scrr_beg * svsp->maxcol),
1982                         svsp->maxcol * (svsp->scrr_len - n) * CHR );
1983         }
1984
1985         fillw(  user_attr | ' ',
1986                 svsp->Crtat + ((svsp->scrr_end - n + 1) * svsp->maxcol),
1987                 n * svsp->maxcol);
1988
1989 /*XXX*/ if(svsp->scroll_lock && svsp->openf && curproc)
1990                 tsleep((caddr_t)&(svsp->scroll_lock), 0, "scrlck", 0);
1991 }
1992
1993 /*---------------------------------------------------------------------------*
1994  *      scroll screen n lines down
1995  *---------------------------------------------------------------------------*/
1996 static void
1997 roll_down(struct video_state *svsp, int n)
1998 {
1999
2000 #if (PCVT_NOFASTSCROLL==0)
2001
2002         if(svsp->scrr_beg == 0 &&       /* if scroll region is whole screen */
2003            svsp->scrr_len == svsp->screen_rows &&
2004            (svsp != vsp ||              /* and either running in memory */
2005             (svsp->screen_rows == svsp->screen_rowsize && /* or no fkeys */
2006              adaptor_type != MDA_ADAPTOR)))     /* and not on MDA/Hercules */
2007         {
2008                 u_short *Memory =
2009
2010 #if PCVT_USL_VT_COMPAT
2011                     (vsp != svsp || (vsp->vt_status & VT_GRAFX)) ?
2012 #else
2013                     (vsp != svsp) ?
2014 #endif
2015                                 svsp->Memory : Crtat;
2016
2017                 if (svsp->Crtat < (Memory + n * svsp->maxcol))
2018                 {
2019                         bcopy(svsp->Crtat,
2020                               Memory + svsp->maxcol * (svsp->screen_rows + n),
2021                               svsp->maxcol * (svsp->screen_rows - n) * CHR);
2022
2023                         svsp->Crtat = Memory + svsp->maxcol * svsp->screen_rows;
2024                 }
2025                 else
2026                 {
2027                         svsp->Crtat -= n * svsp->maxcol;
2028                 }
2029
2030 #if PCVT_USL_VT_COMPAT
2031                 if(vsp == svsp && !(vsp->vt_status & VT_GRAFX))
2032 #else
2033                 if(vsp == svsp)
2034 #endif
2035
2036                 {
2037                         outb(addr_6845, CRTC_STARTADRH);
2038                         outb(addr_6845+1, (svsp->Crtat - Crtat) >> 8);
2039                         outb(addr_6845, CRTC_STARTADRL);
2040                         outb(addr_6845+1, (svsp->Crtat - Crtat));
2041                 }
2042         }
2043         else
2044 #endif
2045         {
2046                 bcopy(  svsp->Crtat + (svsp->scrr_beg * svsp->maxcol),
2047                         svsp->Crtat + ((svsp->scrr_beg + n) * svsp->maxcol),
2048                         svsp->maxcol * (svsp->scrr_len - n) * CHR );
2049         }
2050
2051         fillw(  user_attr | ' ',
2052                 svsp->Crtat + (svsp->scrr_beg * svsp->maxcol),
2053                 n * svsp->maxcol);
2054
2055 /*XXX*/ if(svsp->scroll_lock && svsp->openf && curproc)
2056                 tsleep((caddr_t)&(svsp->scroll_lock), 0, "scrlck", 0);
2057 }
2058
2059 /*---------------------------------------------------------------------------*
2060  *      switch charset pointers
2061  *---------------------------------------------------------------------------*/
2062 static void
2063 swcsp(struct video_state *svsp, u_short *ctp)
2064 {
2065         if(ctp == NULL)
2066                 return;
2067
2068         switch(svsp->state)
2069         {
2070                 case STATE_BROPN:       /* designate G0 */
2071                         svsp->G0 = ctp;
2072                         break;
2073
2074                 case STATE_BRCLO:       /* designate G1 */
2075                 case STATE_MINUS:       /* designate G1 (96) */
2076                         svsp->G1 = ctp;
2077                         break;
2078
2079                 case STATE_STAR:        /* designate G2 */
2080                 case STATE_DOT:         /* designate G2 (96) */
2081                         svsp->G2 = ctp;
2082                         break;
2083
2084                 case STATE_PLUS:        /* designate G3 */
2085                 case STATE_SLASH:       /* designate G3 (96) */
2086                         svsp->G3 = ctp;
2087                         break;
2088         }
2089 }
2090
2091 /*---------------------------------------------------------------------------*
2092  *      process terminal responses
2093  *---------------------------------------------------------------------------*/
2094 static void
2095 respond(struct video_state *svsp)
2096 {
2097         if(!(svsp->openf))              /* are we opened ? */
2098                 return;
2099
2100         while (*svsp->report_chars && svsp->report_count > 0)
2101         {
2102                 (*linesw[svsp->vs_tty->t_line].l_rint)
2103                         (*svsp->report_chars++ & 0xff, svsp->vs_tty);
2104                 svsp->report_count--;
2105         }
2106 }
2107
2108 /*---------------------------------------------------------------------------*
2109  *      Initialization for User Defineable Keys
2110  *---------------------------------------------------------------------------*/
2111 static void
2112 init_udk(struct video_state *svsp)
2113 {
2114         svsp->udk_defi = 0;
2115         svsp->udk_deflow = 0;
2116         svsp->udk_fnckey = 0;
2117 }
2118
2119 /*---------------------------------------------------------------------------*
2120  *      Clear loaded downloadable (DLD) character set
2121  *---------------------------------------------------------------------------*/
2122 static void
2123 clear_dld(struct video_state *svsp)
2124 {
2125         int i;
2126         unsigned char vgacharset;
2127         unsigned char vgachar[16];
2128
2129         if(vgacs[svsp->vga_charset].secondloaded)
2130                 vgacharset = vgacs[svsp->vga_charset].secondloaded;
2131         else
2132                 return;
2133
2134         for(i=0;i < 16;i++)  /* A zeroed character, vt220 has inverted '?' */
2135                 vgachar[i] = 0x00;
2136
2137         for(i=1;i <= 94;i++) /* Load (erase) all characters */
2138                 loadchar(vgacharset, i + 0xA0, 16, vgachar);
2139 }
2140
2141 /*---------------------------------------------------------------------------*
2142  *      Initialization for Down line LoaDable Fonts
2143  *---------------------------------------------------------------------------*/
2144 static void
2145 init_dld(struct video_state *svsp)
2146 {
2147         int i;
2148
2149         svsp->dld_dscsi = 0;
2150         svsp->dld_sixel_lower = 0;
2151         svsp->dld_sixelli = 0;
2152         svsp->dld_sixelui = 0;
2153
2154         for(i = 0;i < MAXSIXEL;i++)
2155                 svsp->sixel.lower[i] = svsp->sixel.upper[i] = 0;
2156 }
2157
2158 /*---------------------------------------------------------------------------*
2159  *      selective erase a region
2160  *---------------------------------------------------------------------------*/
2161 static void
2162 selective_erase(struct video_state *svsp, u_short *pcrtat, int length)
2163 {
2164         int i, j;
2165
2166         for(j = pcrtat - svsp->Crtat, i = 0;i < length;i++,pcrtat++)
2167         {
2168                 if(!(svsp->decsca[INT_INDEX(j+i)] & (1 << BIT_INDEX(j+i))))
2169                 {
2170                         *pcrtat &= 0xFF00; /* Keep the video character attributes */
2171                         *pcrtat += ' ';    /* Erase the character */
2172                 }
2173         }
2174 }
2175
2176 #endif  /* NVT > 0 */
2177
2178 /* ------------------------- E O F ------------------------------------------*/
2179