sys/i386/isa/pcvt/pcvt_vtf.c

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