cde/lib/DtTerm/Term/TermParse.c

   1 /*
   2  * CDE - Common Desktop Environment
   3  *
   4  * Copyright (c) 1993-2012, The Open Group. All rights reserved.
   5  *
   6  * These libraries and programs are free software; you can
   7  * redistribute them and/or modify them under the terms of the GNU
   8  * Lesser General Public License as published by the Free Software
   9  * Foundation; either version 2 of the License, or (at your option)
  10  * any later version.
  11  *
  12  * These libraries and programs are distributed in the hope that
  13  * they will be useful, but WITHOUT ANY WARRANTY; without even the
  14  * implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  15  * PURPOSE. See the GNU Lesser General Public License for more
  16  * details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with these libraries and programs; if not, write
  20  * to the Free Software Foundation, Inc., 51 Franklin Street, Fifth
  21  * Floor, Boston, MA 02110-1301 USA
  22  */
  23 #ifndef lint
  24 #ifdef  VERBOSE_REV_INFO
  25 static char rcs_id[] = "$TOG: TermParse.c /main/3 1999/10/15 12:25:13 mgreess $";
  26 #endif  /* VERBOSE_REV_INFO */
  27 #endif  /* lint */
  28
  29 /*                                                                      *
  30  * (c) Copyright 1993, 1994, 1996 Hewlett-Packard Company               *
  31  * (c) Copyright 1993, 1994, 1996 International Business Machines Corp. *
  32  * (c) Copyright 1993, 1994, 1996 Sun Microsystems, Inc.                *
  33  * (c) Copyright 1993, 1994, 1996 Novell, Inc.                          *
  34  * (c) Copyright 1996 Digital Equipment Corporation.                    *
  35  * (c) Copyright 1996 FUJITSU LIMITED.                                  *
  36  * (c) Copyright 1996 Hitachi.                                          *
  37  */
  38
  39 #include <wctype.h>
  40
  41 #include "TermHeader.h"
  42 #include "TermPrimDebug.h"
  43 #include "TermPrimP.h"
  44 #include "TermPrimI.h"
  45 #include "TermP.h"
  46 #include "TermPrimData.h"
  47 #include "TermData.h"
  48 #include "TermPrimBuffer.h"
  49 #include "TermPrimParserP.h"
  50 #include "TermFunction.h"
  51 #include "TermBuffer.h"
  52 #include "TermFunctionKey.h"
  53 #include "TermParseTableP.h"
  54 #include "TermBufferP.h"
  55 #include "TermPrimUtil.h"
  56 #include "TermPrimParseTable.h"
  57
  58 #if defined (__hpux)
  59 /*
  60  * On HP MAXINT is defined in both <values.h> and <sys/param.h>
  61  */
  62 #undef MAXINT
  63 #endif
  64 #if defined(CSRG_BASED)
  65 #define MAXSHORT SHRT_MAX
  66 #else
  67 #include  <values.h>
  68 #endif
  69
  70 #if defined(USL) || defined(__uxp__)
  71 #include <ctype.h>
  72 #include <wctype.h>
  73 #endif
  74
  75 /*****************************************************************************/
  76
  77 #define NPARAM  16
  78 #define PCOUNT(c)  ((c)->parms[0])
  79 #define BASE   1   /* row and column count base 0 or 1 */
  80
  81 /*********************************************************************
  82  *  Macros for handling cursor constraints - return values in coordinate
  83  *  system for Term widget (base 0)  BASE which is 1 reflects the Vt base
  84  *
  85  *  These defines need to account of for Origin mode eventually  TMH */
  86
  87 #define TOPROW(w)    (1-BASE)
  88 #define TOPMARGIN(w) ((w)->term.tpd->scrollLockTopRow-(1-BASE))
  89 #define BOTTOMMARGIN(w) ((w)->term.tpd->scrollLockBottomRow-(1-BASE))
  90 #define BOTTOMROW(w) ((w)->term.rows-BASE)
  91 /* FIRSTCOLUMN(w)  ABS(BASE-1) */
  92 #define FIRSTCOLUMN(w) 0
  93 #define LASTCOLUMN(w) ((w)->term.columns-BASE)
  94 #define FLOOR(w)  ((w)->vt.td->originMode?(w)->term.tpd->scrollLockBottomRow:\
  95                                              BOTTOMROW(w))
  96 #define CEILING(w)  ((w)->vt.td->originMode?(w)->term.tpd->scrollLockTopRow:\
  97                                              TOPROW(w))
  98 #define KILLWRAP(w) if((w)->term.tpd->cursorColumn>LASTCOLUMN(w)) \
  99                                 (w)->term.tpd->cursorColumn=LASTCOLUMN(w)
 100 #define STORELASTARG(c) (c)->parms[PCOUNT(c)]=(c)->workingNum
 101
 102 /******************************************************************
 103  *   Upon entering a parse routine the parameter count is contained
 104  *   in  context->parms[0].
 105  *
 106  *   The last parmameter parsed is in context->workingNum
 107  *   Next to last parmameter is in {context->parms[0]==1?context->workingNum:
 108  *                                  context->parms[context->param[0]-1]}
 109  *                    .
 110  *                    .
 111  *
 112  *   First parameter is in  context->parms[1]
 113  *
 114  *   In some of the parse routines, the default case of too many parameters
 115  *   needs to be handled like Vt (silently use the first n parameters)
 116  *   Vt has a max of 16 numeric parameters;  The rest fall off the end
 117  *   silently.
 118  *******************************************************************/
 119
 120 void
 121 _DtTermClearParam(Widget w)
 122 {
 123     ParserContext context ;
 124     context = GetParserContext(w) ;
 125
 126     PCOUNT(context)=0 ;
 127     _DtTermPrimParserClearParm(w) ;
 128     _DtTermPrimParserClrStrParm(w) ;
 129 }
 130
 131 void
 132 _DtTermEnterNum(Widget w)
 133 {
 134   ParserContext context ;
 135   context = GetParserContext(w) ;
 136   _DtTermPrimParserEnterNum(w) ;
 137   if (!PCOUNT(context)) PCOUNT(context)++ ; /* increment for first number ONLY*/
 138 }
 139
 140 void
 141 _DtTermParsePushNum(Widget w)
 142 {
 143   ParserContext context ;
 144   context = GetParserContext(w) ;
 145   /* parmN(w,PCOUNT(c)) ;  Should  use this but not global   */
 146   if ( context->workingNumIsDefault != True) {  /* did we actually parse a num*/
 147      _DtTermPrimParserNumParmPush(w,PCOUNT(context)) ;
 148      }
 149   else {
 150    if (!PCOUNT(context)) PCOUNT(context)++ ;/* increment for first number ONLY*/
 151   }
 152
 153   if ( ++PCOUNT(context)>NPARAM ) {
 154     Debug('P',fprintf(stderr,">>Too many parameters\n")) ;
 155     return ;
 156   }
 157 }
 158
 159 void
 160 _DtTermSaveChar(Widget w)
 161 {
 162   DtTermPrimitiveWidget tw = (DtTermPrimitiveWidget) w;
 163   ParserContext context ;
 164   wchar_t c;
 165   context = GetParserContext(w) ;
 166
 167   mbtowc(&c,(char *)context->inputChar,MB_CUR_MAX);
 168   if ( context->stringParms[0].length < STR_SIZE && iswprint(c) ) {
 169       strncpy( (
 170          (char *)&context->stringParms[0].str[context->stringParms[0].length]),
 171                 (char *)context->inputChar, context->inputCharLen) ;
 172    context->stringParms[0].length += context->inputCharLen ;
 173   }
 174 }
 175
 176 void
 177 _DtTermPrintState(Widget w)
 178 {
 179   ParserContext context ;
 180   context = GetParserContext(w) ;
 181   /* fprintf(stderr,"Warning: Not a valid escape sequence\n") ;*/
 182   context->stateTable =  _DtTermStateStart ;
 183   _DtTermClearParam(w) ;
 184 }
 185
 186 /* a utility for checking for S8C1TMode */
 187 static void
 188 sendEscSequence(Widget w, char *transmitString)
 189 {
 190     DtTermWidget    tw  = (DtTermWidget)w;
 191     DtTermData      td = tw->vt.td;
 192
 193     if ( td->S8C1TMode ) {
 194            char *cbuf =malloc(strlen(transmitString)+1);
 195            strcpy(cbuf,transmitString) ;
 196            cbuf[1] = 0x9B ;
 197            (void) _DtTermPrimSendInput(w, (unsigned char *) (cbuf+1),
 198                 strlen(cbuf+1));
 199            free(cbuf) ;
 200          }
 201         else {
 202            (void) _DtTermPrimSendInput(w, (unsigned char *) transmitString,
 203                 strlen(transmitString));
 204         }
 205 }
 206
 207 void
 208 _DtTermDeviceStatus(Widget w)     /* DSR CSI?pn  */
 209 {
 210   DtTermPrimitiveWidget tw = (DtTermPrimitiveWidget) w;
 211   DtTermData vtd = ((DtTermWidget)w)->vt.td;
 212   ParserContext context ;
 213   char buf[100] ;
 214   int col,cnt ;
 215   Debug('P', fprintf(stderr,">>In func  _DtTermDeviceStatus\n")) ;
 216   context = GetParserContext(w) ;
 217   STORELASTARG(context) ;
 218   switch ( context->parms[1] )  {
 219      case 15: /* printer status - we don't have one         */
 220              sendEscSequence(w,"\033[?13n") ;
 221              break;
 222      case 25: /* User defined keys locked?  */
 223              if ( vtd->userKeysLocked )
 224                 sendEscSequence(w,"\033[?21n") ;
 225              else
 226                 sendEscSequence(w,"\033[?20n") ;
 227              break;
 228      case 26: /* keyboard status - always send North American */
 229              sendEscSequence(w,"\033[?27;1n") ;
 230              break;
 231   }
 232 }
 233
 234 void
 235 _DtTermDeviceStatusAnsi(Widget w)     /* DSR CSIpn  */
 236 {
 237   DtTermPrimitiveWidget tw = (DtTermPrimitiveWidget) w;
 238   DtTermData vtd = ((DtTermWidget)w)->vt.td;
 239   ParserContext context ;
 240   char buf[100] ;
 241   int row,col,cnt ;
 242   Debug('P', fprintf(stderr,">>In func  _DtTermDeviceStatus\n")) ;
 243   context = GetParserContext(w) ;
 244   STORELASTARG(context) ;
 245   switch ( context->parms[1] )  {
 246      case 5: /* as far as I know, all's well... So send OK */
 247              sendEscSequence(w,"\033[0n") ;
 248              break;
 249      case 6:
 250        /* cursor could be past last row (for autowrap) */
 251        if ((col=tw->term.tpd->cursorColumn)>LASTCOLUMN(tw))
 252                      col=LASTCOLUMN(tw) ;
 253        row = tw->term.tpd->cursorRow+BASE ;
 254        if (vtd->originMode==True) row -= TOPMARGIN(tw) ;
 255        sprintf(buf,"\033[%d;%dR",row , col+BASE) ;
 256        sendEscSequence(w,buf) ;
 257        break ;
 258   }
 259 }
 260
 261 void
 262 _DtTermPModeSet(Widget w)   /*  DECSET CSI?ph */
 263 {
 264   ParserContext context ;
 265   DtTermPrimitiveWidget tw = (DtTermPrimitiveWidget) w;
 266   DtTermWidget vtw = (DtTermWidget)w;
 267   int i,cnt ;
 268   Debug('P', fprintf(stderr,">>In func _DtTermPModeSet\n")) ;
 269   context = GetParserContext(w) ;
 270   STORELASTARG(context) ;
 271   cnt = PCOUNT(context) ;
 272   for (i=1;i<=cnt;i++) {
 273       switch ( context->parms[i]) {
 274           /* from vt220 */
 275           case 1: /* Cursor key (Application) */
 276                   vtw->vt.td->applicationMode=True;
 277                   break;
 278           /* case 2:  can't return from vt52 mode */
 279           case 3: /* Column (132) */
 280                    if ( vtw->vt.c132 )  {  /* xterm allow 132 mode */
 281                      (void) _DtTermFuncClearBuffer(w, 0, fromParser);
 282                      vtw->term.tpd->cursorRow = TOPROW(vtw) ;
 283                      vtw->term.tpd->cursorColumn = FIRSTCOLUMN(vtw) ;
 284                      vtw->term.tpd->scrollLockTopRow = TOPROW(vtw);
 285                      vtw->term.tpd->scrollLockBottomRow = BOTTOMROW(vtw) ;
 286                      XtVaSetValues(w, DtNcolumns, 132, NULL) ;
 287                      vtw->vt.td->col132Mode = True ;
 288                   }
 289                   break;
 290           case 4: /* Scroll (smooth) */
 291                   _DtTermPrimScrollComplete(w, True) ;
 292                   vtw->term.jumpScroll = False ;
 293                   break;
 294           case 5: /* Screen (Reverse) */
 295                   /*DKS: this is just to test out the functionality... */
 296                   vtw->term.reverseVideo = True;
 297                   /* clear the window to force refresh... */
 298                   (void) XClearArea(XtDisplay(w), XtWindow(w),
 299                         0, 0, 0, 0, True);
 300                   break;
 301           case 6: /* Origin mode (On) */
 302                   vtw->vt.td->originMode=True;
 303                   _DtTermPrimCursorMove(w, TOPMARGIN(vtw), 0);
 304                   break;
 305           case 7: /* Auto wrap (On) */
 306                   vtw->term.tpd->autoWrapRight=True ;
 307                   break;
 308           /* case 8: ** Auto repeat (On)
 309            *      ** This is handled by the X server
 310            *      break;
 311            *
 312            * case 18: ** Print form feed (On)
 313            *      break;
 314            * case 19: ** Print extent (full screen)
 315            *      break;
 316            */
 317           case 25: /* Text cursor enable (On) */
 318                   (void) _DtTermPrimSetCursorVisible(w, True);
 319                   break;
 320            /* from xterm */
 321           case 40: /*  80/132 mode  (allow) */
 322                   vtw->vt.c132 = True ;
 323                   break;
 324           case 41: /*  curses fix */
 325                   vtw->vt.td->fixCursesMode = True ;
 326                   break;
 327           case 44: /* margin bell (on) */
 328                   vtw->term.marginBell = True ;
 329                   break;
 330           case 45: /* Reverse-wraparound mode */
 331                   vtw->vt.td->reverseWrapMode=True;
 332                   break;
 333           case 46: /* logging (start)  */
 334                   vtw->term.logging = True ;
 335                   _DtTermPrimStartLog(w);
 336                   break;
 337           /*  case 47: ** screen buffer (alternate)
 338            *      break;
 339            *  case 1000: ** Send mouse x and y
 340            *      break;
 341            *  case 1001: ** Use hilite mouse tracking
 342            *      break;
 343            */
 344       }
 345    }
 346 }
 347
 348
 349 void
 350 _DtTermPModeReset(Widget w)   /* DECRST CSI?pl */
 351 {
 352   ParserContext context ;
 353   DtTermPrimitiveWidget tw = (DtTermPrimitiveWidget) w;
 354   DtTermWidget vtw = (DtTermWidget)w;
 355   int i,cnt ;
 356   Debug ('P', fprintf(stderr,">>In func _DtTermPModeReset\n")) ;
 357   context = GetParserContext(w) ;
 358   STORELASTARG(context) ;
 359   cnt = PCOUNT(context) ;
 360   for (i=1;i<=cnt;i++) {
 361       switch ( context->parms[i]) {
 362           /* from vt220 */
 363           case 1: /* Cursor key (Normal) */
 364                   vtw->vt.td->applicationMode=False;
 365                   break;
 366           /* case 2:   ** set vt52 mode */
 367           case 3: /* Column (80) */
 368                   if (vtw->vt.c132)  {   /* allow 132 mode */
 369                     (void) _DtTermFuncClearBuffer(w, 0, fromParser);
 370                     vtw->term.tpd->cursorRow = TOPROW(vtw) ;
 371                     vtw->term.tpd->cursorColumn = FIRSTCOLUMN(vtw) ;
 372                     vtw->term.tpd->scrollLockTopRow = TOPROW(vtw);
 373                     vtw->term.tpd->scrollLockBottomRow = BOTTOMROW(vtw) ;
 374                     XtVaSetValues(w, DtNcolumns, 80, NULL) ;
 375                     vtw->vt.td->col132Mode = False ;
 376                   }
 377                   break;
 378           case 4: /* Scroll (jump) */
 379                   _DtTermPrimScrollComplete(w, True) ;
 380                   vtw->term.jumpScroll = True ;
 381                   break;
 382           case 5: /* Screen (normal ) */
 383                   /*DKS: this is just to test out the functionality... */
 384                   vtw->term.reverseVideo = False;
 385                   /* clear the window to force refresh... */
 386                   (void) XClearArea(XtDisplay(w), XtWindow(w),
 387                         0, 0, 0, 0, True);
 388                   break;
 389           case 6: /* Normal cursor (not Origin mode) */
 390                   vtw->vt.td->originMode=False;
 391                   _DtTermPrimCursorMove(w, 0, 0);
 392                   break;
 393           case 7: /* Auto wrap (Off) */
 394                   vtw->term.tpd->autoWrapRight=False;
 395                   break;
 396           /* case 8: ** Auto repeat (Off)
 397            *      ** implemented in the server
 398            *      break;
 399            * case 18: ** Print form feed (Off)
 400            *      break;
 401            * case 19: ** Print extent (scrolling region)
 402            *      break;
 403            */
 404           case 25: /* Text cursor enable (Off) */
 405                   (void) _DtTermPrimSetCursorVisible(w, False);
 406                   break;
 407            /* from xterm */
 408           case 40: /*  80/132 mode  (disallow) */
 409                   vtw->vt.c132 = False;
 410                   break;
 411           case 41: /*  curses fix  */
 412                   vtw->vt.td->fixCursesMode = False;
 413                   break;
 414           case 44: /* margin bell (off) */
 415                   vtw->term.marginBell = False ;
 416                   break;
 417           case 45: /* Reverse-wraparound mode */
 418                   vtw->vt.td->reverseWrapMode=False;
 419                   break;
 420           case 46: /* logging (stop )  */
 421                   vtw->term.logging = False ;
 422                   _DtTermPrimCloseLog(w) ;
 423                   break;
 424           /* case 47: ** screen buffer  (normal)
 425            *      break;
 426            * case 1000: ** don't send mouse x and y
 427            *      break;
 428            * case 1001: ** don't use hilite mouse tracking
 429            *      break;
 430            */
 431       }
 432   }
 433 }
 434
 435 void
 436 _DtTermSetMode(Widget w)   /* SM CSIph */
 437 {
 438   ParserContext context ;
 439   DtTermWidget vtw = (DtTermWidget)w ;
 440   int i,cnt ;
 441   Debug('P', fprintf(stderr,">>In func _DtTermSetMode\n")) ;
 442   context = GetParserContext(w) ;
 443   STORELASTARG(context) ;
 444   cnt = PCOUNT(context) ;
 445   for (i=1;i<=cnt;i++) {
 446       switch ( context->parms[i]) {
 447           case 2: /* KAM Keyboard Action (locked) */
 448                   vtw->term.tpd->keyboardLocked.escape=True ;
 449                   (void) _DtTermPrimInvokeStatusChangeCallback(w);
 450                   break;
 451           case 4: /* Insert mode */
 452                   _DtTermPrimInsertCharUpdate(w, DtTERM_INSERT_CHAR_ON) ;
 453                   break;
 454           case 12: /* SRM Send/Receive (Off) */
 455                   vtw->term.tpd->halfDuplex = False;
 456                   break;
 457           case 20: /* Line feed/newline (new line) */
 458                   vtw->term.tpd->autoLineFeed=True ;
 459                   break;
 460            }
 461     }
 462 }
 463
 464 void
 465 _DtTermResetMode(Widget w)   /* RM CSIpl  */
 466 {
 467   ParserContext context ;
 468   DtTermWidget vtw = (DtTermWidget)w ;
 469   int i,cnt ;
 470   Debug('P', fprintf(stderr,">>In func _DtTermResetMode\n")) ;
 471   context = GetParserContext(w) ;
 472   STORELASTARG(context) ;
 473   cnt = PCOUNT(context) ;
 474   for (i=1;i<=cnt;i++) {
 475       switch ( context->parms[i]) {
 476           case 2: /* KAM Keyboard Action (unlocked) */
 477                   vtw->term.tpd->keyboardLocked.escape=False;
 478                   (void) _DtTermPrimInvokeStatusChangeCallback(w);
 479                   break;
 480           case 4: /* Replace mode */
 481                   _DtTermPrimInsertCharUpdate(w, DtTERM_INSERT_CHAR_OFF) ;
 482                   break;
 483           case 12: /* SRM Send/Receive (On) */
 484                   vtw->term.tpd->halfDuplex = True;
 485                   break;
 486           case 20: /* Line feed/newline (line feed) */
 487                   vtw->term.tpd->autoLineFeed=False ;
 488                   break;
 489            }
 490     }
 491 }
 492
 493 void
 494 _DtTermCursorPos(Widget w)   /* CUP CSIp;pH */
 495 {
 496   ParserContext context ;
 497   DtTermWidget vtw = (DtTermWidget) w;
 498   int row, col;
 499   Debug( 'P', fprintf(stderr,">>In func _DtTermCursorPos\n")) ;
 500   context = GetParserContext(w) ;
 501   STORELASTARG(context) ;
 502   row = context->parms[1] ;
 503   col = context->parms[2] ;
 504   if (row)row-=BASE ;
 505   if (col)col-=BASE ;
 506   if (vtw->vt.td->originMode) row += vtw->term.tpd->scrollLockTopRow ;
 507   if (row > FLOOR(vtw)) row = FLOOR(vtw) ;
 508   if (col > LASTCOLUMN(vtw)) col = LASTCOLUMN(vtw) ;
 509   vtw->term.tpd->cursorRow = row ;
 510   vtw->term.tpd->cursorColumn = col ;
 511 }
 512
 513 void
 514 _DtTermEraseDisplay(Widget w)    /* ED CSIpJ */
 515 {
 516   int cnt ;
 517   DtTermWidget vtw = (DtTermWidget) w;
 518   ParserContext context ;
 519   DtEraseMode   eraseMode;
 520   int  row, col;
 521
 522   Debug('P', fprintf(stderr,">>In func _DtTermEraseDisplay\n")) ;
 523   context = GetParserContext(w) ;
 524   KILLWRAP(vtw) ;
 525   STORELASTARG(context) ;
 526   row = vtw->term.tpd->cursorRow;
 527   col = vtw->term.tpd->cursorColumn ;
 528
 529   /*
 530   ** pick the correct erase mode...
 531   */
 532   switch (context->parms[1])
 533   {
 534     case 0:
 535       eraseMode = eraseToEOB;
 536       break;
 537     case 1:
 538       eraseMode = eraseFromRow0Col0;
 539       break;
 540     case 2:
 541       eraseMode = eraseBuffer;
 542       break ;
 543    }
 544    _DtTermFuncEraseInDisplay(w, (int)eraseMode, fromParser);
 545   vtw->term.tpd->cursorRow = row;
 546   vtw->term.tpd->cursorColumn = col;
 547 }
 548
 549 void
 550 _DtTermEraseChars(Widget w)   /* ECH  CSIpX */
 551 {
 552   ParserContext context ;
 553   DtTermWidget vtw = (DtTermWidget) w;
 554   int row,col,cnt ;
 555   Debug('P', fprintf(stderr,">>In func _DtTermEraseChars\n")) ;
 556   KILLWRAP(vtw) ;
 557   context = GetParserContext(w) ;
 558   row = vtw->term.tpd->cursorRow ;
 559   col = vtw->term.tpd->cursorColumn ;
 560   STORELASTARG(context) ;
 561   cnt = context->parms[1] ;
 562   if (!(cnt))cnt=1;
 563   else
 564     if ( cnt > LASTCOLUMN(vtw)-col+1 ) cnt = LASTCOLUMN(vtw)-col+1 ;
 565
 566   _DtTermFuncEraseCharacter(w, cnt, fromParser);
 567 }
 568
 569 void
 570 _DtTermInsertChars(Widget w)    /* ICH  CSIp@ */
 571 {
 572     DtTermWidget vtw = (DtTermWidget) w;
 573     ParserContext context ;
 574     int row, col, cnt ;
 575     DtTermInsertCharMode        saveInsertCharMode;
 576
 577     Debug('P', fprintf(stderr,">>In func _DtTermInsertChars\n")) ;
 578     KILLWRAP(vtw) ;
 579     context = GetParserContext(w) ;
 580     vtw->term.tpd->parserNotInStartState = False ;
 581     row = vtw->term.tpd->cursorRow ;
 582     col = vtw->term.tpd->cursorColumn ;
 583     STORELASTARG(context) ;
 584     cnt = context->parms[1] ;
 585     if (!cnt)
 586         cnt++;
 587     else
 588         if (cnt > LASTCOLUMN(vtw) - col + 1)
 589             cnt = LASTCOLUMN(vtw) - col + 1;
 590
 591     /* save away the insert char mode... */
 592     saveInsertCharMode = vtw->term.tpd->insertCharMode;
 593
 594     /* turn on insert char mode.  We don't want to invoke any status
 595      * change callbacks, so we will justs set it directly...
 596      */
 597     vtw->term.tpd->insertCharMode = DtTERM_INSERT_CHAR_ON;
 598
 599     /* insert blanks... */
 600     while (cnt--)
 601         (void) _DtTermPrimInsertText(w,(unsigned char *) " ", 1) ;
 602
 603     /* restore the insert char mode... */
 604     vtw->term.tpd->insertCharMode = saveInsertCharMode;
 605
 606     _DtTermPrimCursorMove(w,row,col) ;
 607 }
 608
 609 void
 610 _DtTermCursorUp(Widget w)    /* CUU  CISpA */
 611 {
 612   ParserContext context ;
 613   DtTermWidget vtw = (DtTermWidget) w;
 614   int trow, row, tmargin, cnt;
 615   Debug('P', fprintf(stderr,">>In func _DtTermCursorUp\n")) ;
 616   context = GetParserContext(w) ;
 617   KILLWRAP(vtw) ;
 618   tmargin = TOPMARGIN(vtw) ;
 619   trow = TOPROW(vtw) ;
 620   STORELASTARG(context) ;
 621   cnt = context->parms[1] ;
 622   if (!(cnt))cnt=1;
 623   else if (cnt>MAXSHORT) cnt=MAXSHORT-100;
 624   row = vtw->term.tpd->cursorRow-cnt;
 625   /* are we about the top margin and did we actually cross it? */
 626   /* This handles the case top margin == top row   */
 627   if (row < tmargin && row+cnt >= tmargin) row = tmargin;
 628   _DtTermPrimCursorMove(w, row, vtw->term.tpd->cursorColumn) ;
 629 }
 630
 631 void
 632 _DtTermCursorDown(Widget w)    /* CUD CISpB */
 633 {
 634   ParserContext context ;
 635   DtTermWidget vtw = (DtTermWidget) w;
 636   int  bmargin, row, cnt, brow ;
 637   Debug('P', fprintf(stderr,">>In func _DtTermCursorDown\n")) ;
 638   context = GetParserContext(w) ;
 639   KILLWRAP(vtw) ;
 640   bmargin = BOTTOMMARGIN(vtw) ;
 641   brow = BOTTOMROW(vtw) ;
 642   STORELASTARG(context) ;
 643   cnt = context->parms[1] ;
 644   if (!(cnt))cnt=1;
 645   row = vtw->term.tpd->cursorRow+cnt;
 646   /* are we below bottom margin and did we actually cross it? */
 647   /* NOTE that this also handles the case when bmargin == brow */
 648   if (row > bmargin && row-cnt <= bmargin) row = bmargin;
 649   /* did we start below bottom margin and cross bottom row?   */
 650   if (row > brow && bmargin < brow ) row = brow;
 651   _DtTermPrimCursorMove(w, row, vtw->term.tpd->cursorColumn) ;
 652 }
 653
 654 void
 655 _DtTermCursorForward(Widget w)    /* CUF CISpC */
 656 {
 657   ParserContext context ;
 658   DtTermWidget vtw = (DtTermWidget) w;
 659   int col,lcol,cnt ;
 660   Debug('P', fprintf(stderr,">>In func _DtTermCursorForward\n")) ;
 661   context = GetParserContext(w) ;
 662   KILLWRAP(vtw) ;
 663   lcol = LASTCOLUMN(vtw) ;
 664   STORELASTARG(context) ;
 665   cnt = context->parms[1] ;
 666   if (!cnt) cnt=1;
 667   col = vtw->term.tpd->cursorColumn+cnt;
 668   if (col>lcol) col=lcol;
 669   _DtTermPrimCursorMove(w,vtw->term.tpd->cursorRow,col);
 670 }
 671
 672 void
 673 _DtTermCursorBack(Widget w)    /* CUB CISpD */
 674 {
 675   ParserContext context ;
 676   DtTermWidget vtw = (DtTermWidget) w;
 677   int i,k,j,row,col,fcol,cnt ;
 678   Debug('P', fprintf(stderr,">>In func _DtTermCursorBack\n")) ;
 679   KILLWRAP(vtw) ;
 680   context = GetParserContext(w) ;
 681   STORELASTARG(context) ;
 682   cnt = context->parms[1] ;
 683   fcol = FIRSTCOLUMN(vtw) ;
 684   row = vtw->term.tpd->cursorRow;
 685   col = vtw->term.tpd->cursorColumn;
 686   if (!cnt) cnt=1;
 687   if ((col -= cnt) < 0) {
 688      if(vtw->vt.td->reverseWrapMode && vtw->term.tpd->autoWrapRight) {
 689         int lastrow = BOTTOMROW(vtw);
 690         if (vtw->vt.td->originMode) {
 691            row-=TOPMARGIN(vtw) ;
 692            lastrow = BOTTOMMARGIN(vtw)-TOPMARGIN(vtw);
 693          }
 694         if((i = (j = LASTCOLUMN(vtw) + 1) * row + col) < 0) {
 695               k = j * (lastrow + 1);
 696               i += ((-i) / k + 1) * k;
 697         }
 698         row = i / j;
 699         if (vtw->vt.td->originMode) row+=TOPMARGIN(vtw);
 700         col = i % j;
 701       } else
 702         col = 0;
 703   }
 704   _DtTermPrimCursorMove(w,row,col);
 705 }
 706
 707 void
 708 _DtTermCursorToLineUp(Widget w)   /* CPL  CSIpF */
 709 {
 710   DtTermWidget vtw = (DtTermWidget) w;
 711   ParserContext context ;
 712   Debug('P', fprintf(stderr,">>In func _DtTermCursorToLineUp\n")) ;
 713   KILLWRAP(vtw) ;
 714   context = GetParserContext(w) ;
 715   vtw->term.tpd->cursorColumn = FIRSTCOLUMN(vtw) ;
 716   _DtTermCursorUp(w) ;
 717 }
 718
 719 void
 720 _DtTermCursorToCol(Widget w)    /* CHA CSIpG */
 721 {
 722   DtTermPrimitiveWidget tw = (DtTermPrimitiveWidget) w;
 723   ParserContext context ;
 724   context = GetParserContext(w) ;
 725   STORELASTARG(context) ;
 726   if (!context->parms[1] ) context->parms[1]=1;
 727   if (context->parms[1]>tw->term.columns) context->parms[1]=tw->term.columns;
 728   tw->term.tpd->cursorColumn = context->parms[1] - BASE ;
 729 }
 730
 731 void
 732 _DtTermEraseInLine(Widget w)  /* EL  ESC[pK */
 733 {
 734   DtTermWidget vtw = (DtTermWidget) w;
 735   ParserContext context ;
 736   DtEraseMode eraseMode;
 737
 738
 739   Debug('P', fprintf(stderr,">>In func _DtTermEraseInLine\n")) ;
 740   KILLWRAP(vtw) ;
 741   context = GetParserContext(w) ;
 742   STORELASTARG(context) ;
 743   /*
 744   ** pick the correct erase mode...
 745   */
 746   switch ( context->parms[1] )
 747   {
 748     case 0:
 749       eraseMode = eraseToEOL;
 750       break;
 751
 752     case 1:
 753       eraseMode = eraseFromCol0;
 754       break;
 755
 756     case 2:
 757       eraseMode = eraseLine;
 758       break;
 759
 760   }
 761   _DtTermFuncEraseInLine(w, (int)eraseMode, fromParser);
 762 }
 763
 764 void
 765 _DtTermInsertLines(Widget w)  /* IL CSIpL */
 766 {
 767   DtTermWidget vtw = (DtTermWidget) w;
 768   ParserContext context ;
 769   int lines , cnt ;
 770   Debug('P', fprintf(stderr,">>In func _DtTermInsertLines\n")) ;
 771   if ( vtw->term.tpd->cursorRow < TOPMARGIN(vtw) ||
 772       vtw->term.tpd->cursorRow > BOTTOMMARGIN(vtw) )/*outside scrolling region*/
 773      return ;
 774   context = GetParserContext(w) ;
 775   KILLWRAP((DtTermWidget)w) ;
 776   STORELASTARG(context) ;
 777   cnt=context->parms[1];
 778   if (!cnt)cnt++;
 779   lines  = BOTTOMMARGIN(vtw) -  vtw->term.tpd->cursorRow + 1;
 780   if (cnt > lines) cnt=lines ;
 781   _DtTermFuncInsertLine(w,cnt,fromParser) ;
 782 }
 783
 784 void
 785 _DtTermDeleteLines(Widget w)   /* DL CSIpM */
 786 {
 787   DtTermWidget vtw = (DtTermWidget) w;
 788   ParserContext context ;
 789   int cnt ;
 790   Debug('P', fprintf(stderr,">>In func _DtTermDeleteLines\n")) ;
 791
 792   if ( vtw->term.tpd->cursorRow < TOPMARGIN(vtw) ||
 793       vtw->term.tpd->cursorRow > BOTTOMMARGIN(vtw) )  /* outside scrolling region*/
 794      return ;
 795   KILLWRAP((DtTermWidget)w) ;
 796   context = GetParserContext(w) ;
 797   STORELASTARG(context) ;
 798   cnt = context->parms[1];
 799   if(!cnt)cnt++;
 800   _DtTermFuncDeleteLine(w,cnt,fromParser) ;
 801 }
 802
 803 void
 804 _DtTermDeleteChars(Widget w)   /* DCH CSIpP */
 805 {
 806   ParserContext context ;
 807   DtTermWidget vtw = (DtTermWidget) w;
 808   int cnt ;
 809   Debug('P', fprintf(stderr,">>In func _DtTermDeleteChars\n")) ;
 810   KILLWRAP(vtw) ;
 811   context = GetParserContext(w) ;
 812   STORELASTARG(context) ;
 813   cnt= context->parms[1];
 814   if (!cnt) cnt++;
 815   else if (cnt>MAXSHORT) cnt=MAXSHORT-100;
 816   _DtTermFuncDeleteChar(w,cnt,fromParser) ;
 817 }
 818
 819 void
 820 _DtTermNextLine(Widget w) /* NEL ESCE */
 821 {
 822   DtTermWidget vtw = (DtTermWidget) w;
 823   int brow;
 824   Debug('P', fprintf(stderr,">>In func _DtTermNextLine\n")) ;
 825   vtw->term.tpd->cursorColumn = FIRSTCOLUMN(vtw) ;
 826   _DtTermIndex(w) ;  /* use IND */
 827 }
 828
 829 void
 830 _DtTermReverseIndex(Widget w) /* RI ESCM */
 831 {
 832   DtTermWidget vtw = (DtTermWidget) w;
 833   int tmargin, trow, col;
 834   Debug('P', fprintf(stderr,">>In func _DtTermReverseIndex\n")) ;
 835   KILLWRAP(vtw) ;
 836   trow = TOPROW(vtw) ;
 837   tmargin = TOPMARGIN(vtw) ;
 838   col = vtw->term.tpd->cursorColumn ;
 839   if ( vtw->term.tpd->cursorRow == tmargin) {
 840        _DtTermFuncInsertLine(w,1,fromParser) ;
 841        /* _DtTermFuncInsertLine sets column to first column */
 842        vtw->term.tpd->cursorColumn = col ;
 843    }
 844   else if (vtw->term.tpd->cursorRow > trow){
 845            vtw->term.tpd->cursorRow-- ;
 846    }
 847 }
 848
 849 void
 850 _DtTermIndex(Widget w) /* IND  ESCD */
 851 {
 852   DtTermWidget vtw = (DtTermWidget) w;
 853   int bmargin, brow ;
 854   Debug('P', fprintf(stderr,">>In func _DtTermIndex\n")) ;
 855   KILLWRAP(vtw) ;
 856   brow = BOTTOMROW(vtw) ;
 857   bmargin = BOTTOMMARGIN(vtw) ;
 858   if ( vtw->term.tpd->cursorRow == bmargin) {
 859        (void) _DtTermPrimScrollText(w, 1);
 860    }
 861   else if (vtw->term.tpd->cursorRow < brow){
 862          vtw->term.tpd->cursorRow++ ;
 863    }
 864   (void) _DtTermPrimFillScreenGap(w);
 865 }
 866
 867 void
 868 _DtTermScrollingRegion(Widget w)   /* DECSTBM  CSIp;pr */
 869 {
 870   DtTermWidget vtw = (DtTermWidget)w ;
 871   ParserContext context ;
 872   int row1,row2 ;
 873   Debug('P', fprintf(stderr,">>In func _DtTermScrollingRegion\n")) ;
 874   context = GetParserContext(w) ;
 875   STORELASTARG(context) ;
 876   row1 = context->parms[1] ;
 877   row2 = context->parms[2] ;
 878   if (!row1) row1 = 1 ;
 879   if (!row2 || row2>vtw->term.rows) row2 = vtw->term.rows ;
 880   row1-=BASE ;
 881   row2-=BASE ;
 882   if ( row1 < row2 ) {
 883     if ( row1 == TOPROW(vtw) && row2 == BOTTOMROW(vtw))
 884        vtw->term.tpd->memoryLockMode=SCROLL_LOCKoff ;
 885     else
 886        vtw->term.tpd->memoryLockMode=SCROLL_LOCKon ;
 887     vtw->term.tpd->scrollLockTopRow = row1 ;
 888     vtw->term.tpd->scrollLockBottomRow = row2 ;
 889     if (vtw->vt.td->originMode) _DtTermPrimCursorMove(w,row1,0) ;
 890     else  _DtTermPrimCursorMove(w,0,0) ;
 891   }
 892 }
 893
 894 void
 895 _DtTermCharAttributes(Widget w)   /* SGR CSIpm */
 896 {
 897   ParserContext context ;
 898   int i,cnt ;
 899   Debug('P', fprintf(stderr,">>In func _DtTermCharAttributes\n")) ;
 900   context = GetParserContext(w) ;
 901   STORELASTARG(context) ;
 902   cnt = PCOUNT(context) ;
 903   if(PCOUNT(context)) {
 904     for (cnt=1; cnt <= PCOUNT(context); cnt++)
 905        _DtTermVideoEnhancement(w,context->parms[cnt]) ;
 906    }
 907   else
 908    _DtTermVideoEnhancement(w,0) ;
 909 }
 910
 911 void
 912 _DtTermDeviceAttributes(Widget w)    /* DA CSIpc */
 913 {
 914   DtTermWidget vtw = (DtTermWidget) w;
 915   ParserContext context ;
 916   int cnt ;
 917   char buf[50];
 918   Debug('P', fprintf(stderr,">>In func _DtTermDeviceAttributes\n")) ;
 919   context = GetParserContext(w) ;
 920   STORELASTARG(context) ;
 921   switch(context->parms[1]) {
 922     case 0:
 923          switch(vtw->vt.td->terminalId ) {
 924             case 100:
 925                      sprintf(buf,"\033[?%d;%dc",1,2) ;
 926                      break;
 927             case 101:
 928                      sprintf(buf,"\033[?%d;%dc",1,0) ;
 929                      break;
 930             case 102:
 931                      sprintf(buf,"\033[?%dc",6) ;
 932                      break;
 933             case 220:
 934                 /*  class 2 terminal (62), 132 columns (1), printer port (2),
 935                  *  selective erase (6), DRCS (7), UDK (8),
 936                  *  national replacement char sets
 937                  */
 938                 sprintf(buf,"\033[?%d;%d;%d;%d;%d;%d;%dc",62,1,2,6,7,8,9) ;
 939                 break;
 940           }
 941         sendEscSequence(w,buf) ;
 942         break;
 943   }
 944 }
 945
 946 void
 947 _DtTermChangeTextParam(Widget w)  /* xterm  CSIp;pcCtrl-G  */
 948 {
 949   ParserContext context ;
 950   DtTermWidget tw = (DtTermWidget) w;
 951   DtTermData vtd = tw->vt.td;
 952   Widget sw;
 953   int i ;
 954   Arg arg[5];
 955   Debug('P', fprintf(stderr,">>In func _DtTermChangeTextParam\n")) ;
 956   context = GetParserContext(w) ;
 957   i=0;
 958   for (sw = w; !XtIsShell(sw); sw = XtParent(sw));
 959   /*
 960    *  context->parms[1] is inited to 0, so if no numeric param was entered,
 961    *  we default appropriately to case 0.
 962    */
 963   switch(context->parms[1]) {
 964     case 0: /* change Icon name and Window title */
 965             XtSetArg(arg[i], XmNtitle, context->stringParms[0].str); i++;
 966             XtSetArg(arg[i], XmNiconName, context->stringParms[0].str); i++;
 967             XtSetValues(sw,arg,i) ;
 968             break;
 969     case 1: /* change Icon name */
 970             XtSetArg(arg[i], XmNiconName, context->stringParms[0].str); i++;
 971             XtSetValues(sw,arg,i) ;
 972             break;
 973     case 2: /* change Window title */
 974             XtSetArg(arg[i], XmNtitle, context->stringParms[0].str); i++;
 975             XtSetValues(sw,arg,i) ;
 976             break;
 977     case 3: /* change current working directory */
 978             tw->term.subprocessCWD = XtRealloc(tw->term.subprocessCWD,
 979                     strlen((char *) context->stringParms[0].str) + 1);
 980             (void) strcpy(tw->term.subprocessCWD,
 981                     (char *) context->stringParms[0].str);
 982             break;
 983    /*  These are handled by xterm but not by us.
 984     case 46:  Change log file to context->stringParms[0]
 985             break;
 986     case 50: ** change font to context->stringParms[0]
 987             break;
 988    */
 989   }
 990 }
 991
 992 void
 993 _DtTermTabClear(Widget w)    /*  TBC CSIpg */
 994 {
 995   DtTermPrimitiveWidget tw = (DtTermPrimitiveWidget) w;
 996   TermBuffer tb = tw->term.tpd->termBuffer ;
 997   ParserContext context ;
 998   int type ;
 999   Debug('P', fprintf(stderr,">>In func _DtTermTabClear\n")) ;
1000   context = GetParserContext(w) ;
1001   STORELASTARG(context) ;
1002   type = context->parms[1] ;
1003   switch ( type ) {
1004     case 0:(void)_DtTermPrimBufferClearTab(tb,tw->term.tpd->cursorColumn) ;
1005            break ;
1006     case 3: (void)_DtTermPrimBufferClearAllTabs(tb) ;
1007            break ;
1008    }
1009 }
1010
1011 void
1012 _DtTermRequestParam(Widget w) /* DECREQTPARM CSIpx */
1013 {
1014     ParserContext context ;
1015     int row ;
1016     char buf[100];
1017     Debug('P', fprintf(stderr,">>In func _DtTermRequestParam\n")) ;
1018     context = GetParserContext(w) ;
1019     STORELASTARG(context) ;
1020     row = context->parms[1] ;
1021     if ( row < 2) {
1022        row += 2;
1023
1024        /* row (?), 1 no parity, 1 eight bits, 112 xmit 9600 baud,
1025         * 112, receive 9600 baud, 1 clock multiplier (?),
1026         * 0 STP flags (?)   These are from xterm file 'charproc.c'.
1027         */
1028        sprintf(buf,"\033[%d;%d;%d;%d;%d;%d;%dx",row,1,1,112,112,1,0) ;
1029        sendEscSequence(w,buf) ;
1030      }
1031 }
1032
1033
1034 void
1035 _DtTermTabSet(Widget w) /* HTS ESCH */
1036 {
1037   DtTermPrimitiveWidget tw = (DtTermPrimitiveWidget) w;
1038   TermBuffer tb = tw->term.tpd->termBuffer ;
1039   Debug('P', fprintf(stderr,">>In func _DtTermTabSet\n")) ;
1040   (void)_DtTermPrimBufferSetTab(tb,tw->term.tpd->cursorColumn) ;
1041 }
1042
1043 void
1044 _DtTermSaveCursor(Widget w) /* DECSC ESC7 */
1045 {
1046   DtTermWidget vtw = (DtTermWidget) w;
1047   DtTermPrimitiveWidget tw = (DtTermPrimitiveWidget) w;
1048   DtTermBuffer tb = (DtTermBuffer)tw->term.tpd->termBuffer ;
1049   DtTermData vtd = vtw->vt.td;
1050
1051   Debug('P', fprintf(stderr,">>In func _DtTermSaveCursor\n")) ;
1052   vtd->saveCursor.cursorRow = vtw->term.tpd->cursorRow ;
1053   vtd->saveCursor.cursorColumn = vtw->term.tpd->cursorColumn ;
1054   vtd->saveCursor.originMode    = vtw->vt.td->originMode ;
1055   /* The following is save at the TermPrim level */
1056   /* vtw->vt.td->saveCursor.wrapMode    = */
1057   vtd->saveCursor.enhVideoState = vtd->enhVideoState ;
1058   vtd->saveCursor.enhFieldState = vtd->enhFieldState  ;
1059   vtd->saveCursor.enhFgColorState = vtd->enhFgColorState;
1060   vtd->saveCursor.enhBgColorState = vtd->enhBgColorState;
1061   vtd->saveCursor.GL = vtd->GL;
1062   vtd->saveCursor.GR = vtd->GR;
1063   vtd->saveCursor.G0 = vtd->G0;
1064   vtd->saveCursor.G1 = vtd->G1;
1065   vtd->saveCursor.G2 = vtd->G2;
1066   vtd->saveCursor.G3 = vtd->G3;
1067   vtd->saveCursor.singleShiftFont = vtd->singleShiftFont;
1068   vtd->saveCursor.singleShiftPending = vtd->singleShiftPending;
1069 }
1070
1071 void
1072 _DtTermRestoreCursor(Widget w) /* DECRC ESC8 */
1073 {
1074   DtTermPrimitiveWidget      tw        = (DtTermPrimitiveWidget) w;
1075   DtTermPrimData        tpd        = tw->term.tpd;
1076   DtTermWidget vtw = (DtTermWidget) w;
1077   DtTermData vtd = vtw->vt.td;
1078
1079   Debug('P', fprintf(stderr,">>In func _DtTermRestoreCursor\n")) ;
1080   tpd->cursorRow = vtd->saveCursor.cursorRow ;
1081   tpd->cursorColumn = vtd->saveCursor.cursorColumn ;
1082   vtw->vt.td->originMode = vtd->saveCursor.originMode    ;
1083   tpd->autoWrapRight = vtd->saveCursor.wrapMode ;
1084   vtd->enhVideoState  = vtd->saveCursor.enhVideoState ;
1085   vtd->enhFieldState  = vtd->saveCursor.enhFieldState ;
1086   vtd->enhFgColorState = vtd->saveCursor.enhFgColorState;
1087   vtd->enhBgColorState = vtd->saveCursor.enhBgColorState;
1088   vtd->GR = vtd->saveCursor.GR;
1089   vtd->GL = vtd->saveCursor.GL;
1090   vtd->G0 = vtd->saveCursor.G0;
1091   vtd->G1 = vtd->saveCursor.G1;
1092   vtd->G2 = vtd->saveCursor.G2;
1093   vtd->G3 = vtd->saveCursor.G3;
1094   vtd->singleShiftFont = vtd->saveCursor.singleShiftFont;
1095   vtd->singleShiftPending = vtd->saveCursor.singleShiftPending;
1096   (void)_DtTermPrimBufferSetEnhancement(tpd->termBuffer,
1097               tpd->topRow + tpd->cursorRow, tpd->cursorColumn, enhVideo,
1098               vtd->enhVideoState);
1099   (void)_DtTermPrimBufferSetEnhancement(tpd->termBuffer,
1100               tpd->topRow + tpd->cursorRow, tpd->cursorColumn, enhField,
1101               vtd->enhFieldState);
1102   (void)_DtTermPrimBufferSetEnhancement(tpd->termBuffer,
1103               tpd->topRow + tpd->cursorRow, tpd->cursorColumn, enhFont,
1104               *(vtd->GL));
1105   (void)_DtTermPrimBufferSetEnhancement(tpd->termBuffer,
1106               tpd->topRow + tpd->cursorRow, tpd->cursorColumn, enhBgColor,
1107               vtd->saveCursor.enhBgColorState);
1108   (void)_DtTermPrimBufferSetEnhancement(tpd->termBuffer,
1109               tpd->topRow + tpd->cursorRow, tpd->cursorColumn, enhFgColor,
1110               vtd->saveCursor.enhFgColorState);
1111   if ( vtd->originMode ) {
1112      if (tpd->cursorRow < tpd->scrollLockTopRow )
1113         tpd->cursorRow = tpd->scrollLockTopRow ;
1114      else if (tpd->cursorRow > tpd->scrollLockBottomRow )
1115         tpd->cursorRow = tpd->scrollLockBottomRow ;
1116   }
1117 }
1118
1119 void
1120 _DtTermAppKeypad(Widget w)  /* DECPAM  ESC= */
1121 {
1122   DtTermWidget vtw = (DtTermWidget) w;
1123   Debug('P', fprintf(stderr,">>In func _DtTermAppKeypad\n")) ;
1124   vtw->vt.td->applicationKPMode=True;
1125 }
1126
1127 void
1128 _DtTermNormalKeypad(Widget w) /* DECPNM ESC> */
1129 {
1130   DtTermWidget vtw = (DtTermWidget) w;
1131   Debug('P', fprintf(stderr,">>In func _DtTermNormalKeypad\n")) ;
1132   vtw->vt.td->applicationKPMode=False;
1133 }
1134
1135 void
1136 _DtTermS8C1T(Widget w)   /* S8C1T  ESCG  */
1137 {
1138   DtTermWidget vtw = (DtTermWidget) w;
1139   Debug('P', fprintf(stderr,">>In func _vt8CIT\n")) ;
1140   vtw->vt.td->S8C1TMode=True;
1141 }
1142
1143 void
1144 _DtTermS7C1T(Widget w)   /* S7C1T  ESCF */
1145 {
1146   DtTermWidget vtw = (DtTermWidget) w;
1147   Debug('P', fprintf(stderr,">>In func _vt8CIT\n")) ;
1148   vtw->vt.td->S8C1TMode=False;
1149 }
1150
1151 void
1152 _DtTermSetCompatLevel(Widget w)   /* DECSCL CSI p;p"p (last p literal) */
1153 {
1154   ParserContext context ;
1155   DtTermWidget vtw = (DtTermWidget) w;
1156   Debug('P', fprintf(stderr,">>In func _DtTermSetCompatLevel\n")) ;
1157   context = GetParserContext(w) ;
1158   STORELASTARG(context) ;
1159   vtw->vt.td->compatLevel= 2;  /* assume vt200 mode */
1160   switch ( PCOUNT(context) )  {
1161       case 1: switch (context->parms[1]) {
1162                  case 61:  vtw->vt.td->compatLevel= 1;
1163                            vtw->vt.td->S8C1TMode=False;
1164                            break;
1165                  case 62:  vtw->vt.td->S8C1TMode=True;
1166                            break;
1167                }
1168               break;
1169       case 2: switch (context->parms[2]) {
1170                  case 0:
1171                  case 2: vtw->vt.td->S8C1TMode=True;
1172                          break;
1173                  case 1:
1174                          vtw->vt.td->S8C1TMode=False;
1175                          break;
1176                }
1177     }
1178 }
1179
1180 void
1181 _DtTermInvokeG3(Widget w)  /* LS3R  ESC| */
1182 {
1183   ParserContext context ;
1184   int cnt ;
1185   Debug('P', fprintf(stderr,">>In func _DtTermInvokeG3\n")) ;
1186   context = GetParserContext(w) ;
1187 }
1188
1189 void
1190 _DtTermInvokeG2(Widget w)  /* LS3R  ESC} */
1191 {
1192   ParserContext context ;
1193   int cnt ;
1194   Debug('P', fprintf(stderr,">>In func _DtTermInvokeG2\n")) ;
1195   context = GetParserContext(w) ;
1196 }
1197
1198 void
1199 _DtTermScrollUp(Widget w)    /* SU CSIpS */
1200 {
1201     ParserContext context ;
1202     DtTermWidget vtw = (DtTermWidget) w;
1203     int row,col,cnt ;
1204
1205     Debug('P', fprintf(stderr,">>In func _DtTermScrollUp\n")) ;
1206 #define  EXIT_IF_OUTSIDE_SR(w) if((w)->term.tpd->scrollLockTopRow >  \
1207                                    (w)->term.tpd->cursorRow  ||    \
1208                                    (w)->term.tpd->scrollLockBottomRow < \
1209                                    (w)->term.tpd->cursorRow)   \
1210                                    return;
1211     EXIT_IF_OUTSIDE_SR(vtw)
1212     KILLWRAP(vtw) ;
1213     context = GetParserContext(w) ;
1214     row = vtw->term.tpd->cursorRow;
1215     col = vtw->term.tpd->cursorColumn;
1216     STORELASTARG(context) ;
1217     if (!context->parms[1])
1218         context->parms[1] = 1;
1219     else if (context->parms[1] > MAXSHORT)
1220         context->parms[1] = MAXSHORT - 100;
1221
1222     /* clip the number of rows to the scroll region... */
1223     if (context->parms[1] > (vtw->term.tpd->scrollLockBottomRow -
1224             vtw->term.tpd->scrollLockTopRow + 1)) {
1225         context->parms[1] = vtw->term.tpd->scrollLockBottomRow -
1226                 vtw->term.tpd->scrollLockTopRow + 1;
1227     }
1228
1229     vtw->term.tpd->cursorRow = TOPMARGIN(vtw) ;
1230     _DtTermFuncDeleteLine(w, context->parms[1], fromParser);
1231     vtw->term.tpd->cursorRow = row;
1232     vtw->term.tpd->cursorColumn = col;
1233 }
1234
1235 void
1236 _DtTermScrollDown(Widget w)  /* SD CSIpT */
1237 {
1238     ParserContext context ;
1239     DtTermWidget vtw = (DtTermWidget) w;
1240     int row,col,cnt ;
1241
1242     Debug('P', fprintf(stderr,">>In func _DtTermScrollDown\n")) ;
1243     EXIT_IF_OUTSIDE_SR(vtw)
1244     KILLWRAP(vtw) ;
1245     context = GetParserContext(w) ;
1246     row = vtw->term.tpd->cursorRow;
1247     col = vtw->term.tpd->cursorColumn ;
1248     STORELASTARG(context) ;
1249     if (!context->parms[1])
1250         context->parms[1] = 1;
1251     else if (context->parms[1] > MAXSHORT)
1252         context->parms[1] = MAXSHORT - 100;
1253
1254     /* clip the number of rows to the scroll region... */
1255     if (context->parms[1] > (vtw->term.tpd->scrollLockBottomRow -
1256             vtw->term.tpd->scrollLockTopRow) + 1) {
1257         context->parms[1] = vtw->term.tpd->scrollLockBottomRow -
1258                 vtw->term.tpd->scrollLockTopRow + 1;
1259     }
1260
1261     vtw->term.tpd->cursorRow = TOPMARGIN(vtw) ;
1262     _DtTermFuncInsertLine(w, context->parms[1], fromParser) ;
1263     vtw->term.tpd->cursorRow = row;
1264     vtw->term.tpd->cursorColumn = col;
1265 }
1266
1267 void
1268 _DtTermRestoreModeValues(Widget w)  /* xterm - Restore DEC mode values CSI?pr */
1269 {
1270   ParserContext context ;
1271   DtTermPrimitiveWidget tw = (DtTermPrimitiveWidget) w;
1272   DtTermWidget vtw = (DtTermWidget)w;
1273   DtTermData vtd = vtw->vt.td;
1274   int i,cnt ;
1275   Debug ('P', fprintf(stderr,">>In func _DtTermPModeReset\n")) ;
1276   context = GetParserContext(w) ;
1277   STORELASTARG(context) ;
1278   cnt = PCOUNT(context) ;
1279   for (i=1;i<=cnt;i++) {
1280       switch ( context->parms[i]) {
1281           /* from vt220 */
1282           case 1: /* Cursor key (Normal/Application) */
1283                   vtd->applicationMode = vtd->saveDECMode.applicationMode ;
1284                   break;
1285 #ifdef  NOT_SUPPORTED
1286           case 2:  /* set vt52 mode */
1287                   break;
1288 #endif  /* NOT_SUPPORTED */
1289           case 3: /* Columns (80/132) */
1290                   vtd->col132Mode = vtd->saveDECMode.col132Mode ;
1291                   break;
1292           case 4: /* Scroll Mode ( jump/smooth ) */
1293                   _DtTermPrimScrollComplete(w, True) ;
1294                   vtw->term.jumpScroll = vtd->saveDECMode.jumpScrollMode ;
1295                   break;
1296           case 5: /* Screen mode */
1297                   vtw->term.reverseVideo = vtd->saveDECMode.inverseVideoMode ;
1298                   break;
1299           case 6: /*  Origin mode (on/off)*/
1300                   vtd->originMode = vtd->saveDECMode.originMode ;
1301                   break;
1302           case 7: /* Auto wrap (On/Off) */
1303                   vtw->term.tpd->autoWrapRight = vtd->saveDECMode.wrapMode ;
1304                   break;
1305           case 8: /* Auto repeat (Off) */
1306                   /* implemented in the server */
1307                   break;
1308 #ifdef  NOT_SUPPORTED
1309           case 18: /* Print form feed (Off) */
1310                   break;
1311           case 19: /* Print extent (scrolling region) */
1312                   break;
1313 #endif  /* NOT_SUPPORTED */
1314           case 25: /* Text cursor enable (Off) */
1315                   _DtTermPrimSetCursorVisible(w,
1316                         vtd->saveDECMode.cursorVisible);
1317                   break;
1318
1319            /* from xterm */
1320           case 40: /*  80/132 mode  (disallow/allow) */
1321                   vtw->vt.c132 = vtd->saveDECMode.allow80_132ColMode;
1322                   break;
1323           case 41: /*  curses fix  (off/on) */
1324                   vtd->fixCursesMode = vtd->saveDECMode.fixCursesMode;
1325                   break;
1326           case 44: /* margin bell (off/on) */
1327                   vtw->term.marginBell = vtd->saveDECMode.marginBellMode;
1328                   break;
1329           case 45: /* Reverse-wraparound mode */
1330                   vtd->reverseWrapMode = vtd->saveDECMode.reverseWrapMode ;
1331                   break;
1332           case 46: /* logging (stop/start )  */
1333                   if (vtd->saveDECMode.logging) {
1334                       vtw->term.logging = True ;
1335                       _DtTermPrimStartLog(w);
1336                   } else {
1337                       vtw->term.logging = False ;
1338                       _DtTermPrimCloseLog(w) ;
1339                   }
1340                   break;
1341 #ifdef  NOT_SUPPORTED
1342           case 47: /* screen buffer  (normal) */
1343                   break;
1344           case 1000: /* don't send mouse x and y */
1345                   break;
1346           case 1001: /* don't use hilite mouse tracking */
1347                   break;
1348 #endif  /* NOT_SUPPORTED */
1349       }
1350    }
1351 }
1352
1353 void
1354 _DtTermSaveModeValues(Widget w)  /* xterm - Save DEC mode values CSI?ps  */
1355 {
1356   ParserContext context ;
1357   DtTermPrimitiveWidget tw = (DtTermPrimitiveWidget) w;
1358   DtTermWidget vtw = (DtTermWidget)w;
1359   DtTermData vtd = vtw->vt.td;
1360   int i,cnt ;
1361   Debug ('P', fprintf(stderr,">>In func _DtTermPModeReset\n")) ;
1362   context = GetParserContext(w) ;
1363   STORELASTARG(context) ;
1364   cnt = PCOUNT(context) ;
1365   for (i=1;i<=cnt;i++) {
1366       switch ( context->parms[i]) {
1367           /* from vt220 */
1368           case 1: /* Cursor key (Normal/Application) */
1369                   vtd->saveDECMode.applicationMode = vtd->applicationMode ;
1370                   break;
1371 #ifdef  NOT_SUPPORTED
1372           case 2:  /* set vt52 mode */
1373                   break;
1374 #endif  /* NOT_SUPPORTED */
1375           case 3: /* Columns (80/132) */
1376                   vtd->saveDECMode.col132Mode = vtd->col132Mode ;
1377                   break;
1378           case 4: /* Scroll Mode ( jump/smooth ) */
1379                   vtd->saveDECMode.jumpScrollMode = vtw->term.jumpScroll ;
1380                   break;
1381           case 5: /* Screen mode */
1382                   vtd->saveDECMode.inverseVideoMode = vtw->term.reverseVideo ;
1383                   break;
1384           case 6: /*  Origin mode (on/off)*/
1385                   vtd->saveDECMode.originMode = vtd->originMode ;
1386                   break;
1387           case 7: /* Auto wrap (On/Off) */
1388                   vtd->saveDECMode.wrapMode = vtw->term.tpd->autoWrapRight ;
1389                   break;
1390           case 8: /* Auto repeat (Off) */
1391                   /* implemented in the server */
1392                   break;
1393 #ifdef  NOT_SUPPORTED
1394           case 18: /* Print form feed (Off) */
1395                   break;
1396           case 19: /* Print extent (scrolling region) */
1397                   break;
1398 #endif  /* NOT_SUPPORTED */
1399           case 25: /* Text cursor enable (Off) */
1400                   vtd->saveDECMode.cursorVisible =
1401                             _DtTermPrimGetCursorVisible(w);
1402                   break;
1403            /* from xterm */
1404           case 40: /*  80/132 mode  (disallow/allow) */
1405                   vtd->saveDECMode.allow80_132ColMode = vtw->vt.c132;
1406                   break;
1407           case 41: /*  curses fix  (off/on) */
1408                   vtd->saveDECMode.fixCursesMode = vtd->fixCursesMode ;
1409                   break;
1410           case 44: /* margin bell (off/on) */
1411                   vtd->saveDECMode.marginBellMode = vtw->term.marginBell ;
1412                   break;
1413           case 45: /* Reverse-wraparound mode */
1414                   vtd->saveDECMode.reverseWrapMode = vtd->reverseWrapMode ;
1415                   break;
1416           case 46: /* logging (stop/start ) */
1417                   vtd->saveDECMode.logging = vtw->term.logging;
1418                   break;
1419 #ifdef  NOT_SUPPORTED
1420           case 47: /* screen buffer  (normal) */
1421                   break;
1422           case 1000: /* don't send mouse x and y */
1423                   break;
1424           case 1001: /* don't use hilite mouse tracking */
1425                   break;
1426 #endif  /* NOT_SUPPORTED */
1427       }
1428    }
1429 }
1430
1431
1432 void
1433 _DtTermAlignTest(Widget w)     /* DECALN ESC#8 */
1434 {
1435   DtTermWidget vtw = (DtTermWidget) w;
1436   int tlrow, blrow, cnt ;
1437   Debug('P', fprintf(stderr,">>In func _DtTermAlignTest\n")) ;
1438   vtw->term.tpd->parserNotInStartState = False ;
1439   tlrow =  vtw->term.tpd->scrollLockTopRow ;
1440   blrow =  vtw->term.tpd->scrollLockBottomRow ;
1441   vtw->term.tpd->scrollLockTopRow = TOPROW(w) ; ;
1442   vtw->term.tpd->scrollLockBottomRow = BOTTOMROW(vtw) ;
1443   cnt = (BOTTOMROW(vtw)+BASE)*(LASTCOLUMN(vtw)+BASE);
1444   vtw->term.tpd->cursorColumn = FIRSTCOLUMN(w) ;
1445   vtw->term.tpd->cursorRow    = TOPROW(w) ;
1446   while(cnt--) _DtTermPrimInsertText(w,(unsigned char *) "E", 1) ;
1447   vtw->term.tpd->scrollLockTopRow = tlrow ;
1448   vtw->term.tpd->scrollLockBottomRow = blrow ;
1449   vtw->term.tpd->cursorRow = CEILING(vtw) ;
1450   vtw->term.tpd->cursorColumn = FIRSTCOLUMN(w) ;
1451 }
1452
1453 void
1454 _DtTermInvokeG1(Widget w)     /* ESC~ESC */
1455 {
1456   ParserContext context ;
1457   int cnt ;
1458   Debug('P', fprintf(stderr,">>In func _DtTermInvokeG1\n")) ;
1459   context = GetParserContext(w) ;
1460 }
1461
1462 void
1463 _DtTermSelEraseInLine(Widget w) /* DECSEL ESC?pK */
1464 {
1465     DtTermWidget vtw = (DtTermWidget) w;
1466     DtTermPrimitiveWidget tw = (DtTermPrimitiveWidget) w;
1467     TermBuffer tb = tw->term.tpd->termBuffer ;
1468     DtTermPrimData  tpd = tw->term.tpd;
1469     DtTermData  td = vtw->vt.td;
1470     ParserContext context ;
1471     enhValues evalues;
1472     int c,col1,col2,col,row ;
1473     short cnt ;
1474     DtTermInsertCharMode        saveInsertCharMode;
1475
1476     Debug('P', fprintf(stderr,">>In func _DtTermSelEraseInLine\n")) ;
1477     KILLWRAP(vtw) ;
1478     context = GetParserContext(w) ;
1479     STORELASTARG(context) ;
1480     col1 = FIRSTCOLUMN(vtw) ;
1481     col2 = LASTCOLUMN(vtw) ;
1482     switch ( context->parms[1] )  {
1483     case 0:
1484         col1= tpd->cursorColumn;
1485         break;
1486     case 1:
1487         col2 = tpd->cursorColumn;
1488         break;
1489     case 2:
1490         break ;
1491     default:
1492         return ;
1493     }
1494     /* save away the current cursor position... */
1495     col = tpd->cursorColumn ;
1496     row = tpd->cursorRow    ;
1497
1498     /* save away the current insert mode... */
1499     saveInsertCharMode = vtw->term.tpd->insertCharMode;
1500
1501     /* insert char needs to be off... */
1502     tpd->insertCharMode = DtTERM_INSERT_CHAR_OFF;
1503
1504     tpd->parserNotInStartState = False ;
1505     c = col1;
1506
1507     while (c <= col2) {
1508         (void)_DtTermPrimBufferGetEnhancement(tb, tpd->cursorRow,
1509                     c, &evalues, &cnt, countAll);
1510         if (!cnt)
1511             break ;
1512         if (evalues[(int)enhField] == FIELD_UNPROTECT) {
1513             (void) _DtTermPrimBufferSetEnhancement(tb, tpd->cursorRow,
1514                     c, enhVideo, evalues[(int)enhVideo]);
1515             (void) _DtTermPrimBufferSetEnhancement(tb, tpd->cursorRow,
1516                     c, enhFgColor, evalues[(int)enhFgColor]);
1517             (void) _DtTermPrimBufferSetEnhancement(tb, tpd->cursorRow,
1518                     c, enhBgColor, evalues[(int)enhBgColor]);
1519             while ((c <= col2) && cnt--) {
1520                 tpd->cursorColumn = c;
1521                 (void) _DtTermPrimInsertText(w, (unsigned char *) " ", 1);
1522                 c++;
1523             }
1524         } else {
1525             c += cnt;
1526         }
1527     }
1528
1529     /* restore the insert char mode... */
1530     tpd->insertCharMode = saveInsertCharMode;
1531
1532     /* restore the cursor position... */
1533     tpd->cursorColumn = col;
1534     tpd->cursorRow = row;
1535
1536     /* restore the current enhancement state... */
1537     (void)_DtTermPrimBufferSetEnhancement(tpd->termBuffer,
1538               tpd->topRow + tpd->cursorRow, tpd->cursorColumn, enhVideo,
1539               td->enhVideoState);
1540     (void)_DtTermPrimBufferSetEnhancement(tpd->termBuffer,
1541               tpd->topRow + tpd->cursorRow, tpd->cursorColumn, enhFgColor,
1542               td->enhFgColorState);
1543     (void)_DtTermPrimBufferSetEnhancement(tpd->termBuffer,
1544               tpd->topRow + tpd->cursorRow, tpd->cursorColumn, enhBgColor,
1545               td->enhBgColorState);
1546 }
1547
1548 void
1549 _DtTermSelEraseInDisplay(Widget w) /* DECSED ESC?pJ */
1550 {
1551   DtTermWidget vtw = (DtTermWidget) w;
1552   DtTermPrimitiveWidget tw = (DtTermPrimitiveWidget) w;
1553   TermBuffer tb = tw->term.tpd->termBuffer ;
1554   ParserContext context ;
1555   enhValues evalues;
1556   int r,col1,col2,row1,row2,col,row ;
1557   int   cnt ;
1558   Debug('P', fprintf(stderr,">>In func _DtTermSelEraseInDisplay\n")) ;
1559   KILLWRAP(vtw) ;
1560   context = GetParserContext(w) ;
1561   STORELASTARG(context) ;
1562   col1 = FIRSTCOLUMN(vtw) ;
1563   row1 = TOPROW(vtw) ;
1564   col2 = LASTCOLUMN(vtw) ;
1565   row2 = BOTTOMROW(vtw) ;
1566   switch ( context->parms[1] )  {
1567       case 0: col1= vtw->term.tpd->cursorColumn;
1568               row1 = vtw->term.tpd->cursorRow;
1569               break;
1570       case 1: col2 = vtw->term.tpd->cursorColumn;
1571               row2 = vtw->term.tpd->cursorRow;
1572               break;
1573       case 2: break ;
1574       default: return ;
1575     }
1576   col = vtw->term.tpd->cursorColumn;
1577   row = vtw->term.tpd->cursorRow;
1578   vtw->term.tpd->cursorColumn = col1 ;
1579   vtw->term.tpd->cursorRow = row1;
1580   context->workingNum  = 0 ;  /* erase to the end of line */
1581   _DtTermSelEraseInLine(w) ;
1582   context->workingNum  = 2 ;  /* erase the whole row */
1583   for ( r=row1+1; r<row2; r++) {
1584      vtw->term.tpd->cursorRow = r;
1585      _DtTermSelEraseInLine(w) ;
1586    }
1587   vtw->term.tpd->cursorColumn = col2 ;
1588   vtw->term.tpd->cursorRow = row2;
1589   context->workingNum  = 2 ;  /* erase the beginning of the line */
1590   _DtTermSelEraseInLine(w) ;
1591   vtw->term.tpd->cursorColumn = col ;
1592   vtw->term.tpd->cursorRow = row;
1593 }
1594
1595
1596 void
1597 _DtTermSingleShiftG2(Widget w) /* SS2  ESCN */
1598 {
1599   DtTermWidget vtw = (DtTermWidget) w;
1600   DtTermData vtd =      vtw->vt.td;
1601
1602   Debug('P', fprintf(stderr,">>In func _DtTermSingleShiftG2\n")) ;
1603   vtd->singleShiftPending = True;
1604   vtd->singleShiftFont = vtd->G2;
1605 }
1606
1607 void
1608 _DtTermSingleShiftG3(Widget w) /* SS3  ESCO */
1609 {
1610   DtTermWidget vtw = (DtTermWidget) w;
1611   DtTermData vtd =      vtw->vt.td;
1612
1613   Debug('P', fprintf(stderr,">>In func _DtTermSingleShiftG3\n")) ;
1614   vtd->singleShiftPending = True;
1615   vtd->singleShiftFont = vtd->G3;
1616 }
1617
1618 void
1619 _DtTermLoadCharSet(Widget w) /* vt220 DCS - download char set ESCPpST  */
1620 {
1621   /* we're not implementing this */
1622 }
1623
1624 /*********************************************************************
1625  *  The next 3 functions handle the user key string loading
1626  *    DCS Pc;Pl | Ky1/st1;ky2/st2;...kyn/stn ST
1627  */
1628 void
1629 _DtTermParseUserKeyClear(Widget w) /* vt220 DECUDK clear function keys*/
1630 {
1631   DtTermWidget vtw = (DtTermWidget) w;
1632   DtTermData vtd =      vtw->vt.td;
1633   ParserContext context ;
1634   Debug('P', fprintf(stderr,">>In func _DtTermLoadSoftKey\n")) ;
1635   context = GetParserContext(w) ;
1636   STORELASTARG(context) ;
1637   if ( !vtd->userKeysLocked )
1638   {
1639      vtd->needToLockUserKeys = False ;
1640      if (context->parms[1] == 0)
1641         _DtTermFunctionKeyClear(w) ;
1642      if (context->parms[0] == 2 && context->parms[2] == 0)
1643                                       vtd->needToLockUserKeys = True ;
1644   }
1645   _DtTermClearParam(w) ;
1646 }
1647 void
1648 _DtTermParseUserKeyLoad(Widget w) /* vt220 DECUDK load function string */
1649 {
1650   DtTermWidget vtw = (DtTermWidget) w;
1651   DtTermData vtd =      vtw->vt.td;
1652   ParserContext context ;
1653   Debug('P', fprintf(stderr,">>In func _DtTermLoadSoftKey\n")) ;
1654   context = GetParserContext(w) ;
1655   STORELASTARG(context) ;
1656   if ( !vtd->userKeysLocked)
1657   {
1658      context->stringParms[0].str[context->stringParms[0].length/2] =
1659                           (unsigned char)0 ;  /* Null terminate */
1660      _DtTermFunctionKeyStringStore(w,context->parms[1],
1661                                            (char *)context->stringParms[0].str);
1662   }
1663   _DtTermClearParam(w) ;
1664 }
1665
1666 void
1667 _DtTermParseUserKeyLoadLast(Widget w) /* vt220 DECUDK load function string */
1668 {
1669   DtTermWidget vtw = (DtTermWidget) w;
1670   DtTermData vtd =      vtw->vt.td;
1671    _DtTermParseUserKeyLoad(w);
1672   if (vtd->needToLockUserKeys) vtd->userKeysLocked = True ;
1673   vtd->needToLockUserKeys = False ;
1674 }
1675
1676 void
1677 _DtTermParseHexDigit(Widget w) /* vt220 DECUDK store hex digit*/
1678 {
1679   ParserContext context ;
1680   int ci, left_byte, i;
1681   char c, cbuf[2] ;
1682   Debug('P', fprintf(stderr,">>In func _DtTermLoadSoftKey\n")) ;
1683   context = GetParserContext(w) ;
1684   if ( (int)context->stringParms[0].length < 2*STR_SIZE-1 ) {
1685       /* fold the hex digits into characters */
1686       i = context->stringParms[0].length ;
1687       cbuf[0] = *context->inputChar ;
1688       cbuf[1] = (char)0 ;
1689       sscanf(cbuf,"%x",&ci)   ;
1690       c = (char)ci ;
1691       left_byte  = (i+1)%2 ;
1692       i /= 2 ;
1693       if ( left_byte  )
1694            context->stringParms[0].str[i] = c<<4 ;
1695       else
1696            context->stringParms[0].str[i] |= c & 0x0F ;
1697       context->stringParms[0].length++ ;
1698    }
1699 }
1700
1701 void
1702 _DtTermReset(Widget w) /* RIS  ESCc */
1703 {
1704   ParserContext context ;
1705   int cnt ;
1706   Debug('P', fprintf(stderr,">>In func _DtTermReset\n")) ;
1707   context = GetParserContext(w) ;
1708   _DtTermFuncHardReset(w,0 ,fromParser) ;
1709 }
1710
1711 void
1712 _DtTermSelectG2(Widget w) /* LS2  ESCn */
1713 {
1714     DtTermWidget vtw = (DtTermWidget)w ;
1715     DtTermData vtd =      vtw->vt.td;
1716     DtTermPrimitiveWidget tw         = (DtTermPrimitiveWidget) w;
1717     DtTermPrimData        tpd        = tw->term.tpd;
1718
1719     Debug('P', fprintf(stderr,">>In func _DtTermSelectG2\n")) ;
1720     vtd->GL = &vtd->G2;
1721
1722     vtd->enhFontState = *vtd->GL;
1723     (void)_DtTermPrimBufferSetEnhancement(tpd->termBuffer,
1724             tpd->topRow + tpd->cursorRow, tpd->cursorColumn,
1725             enhFont, vtd->enhFontState);
1726 }
1727
1728 void
1729 _DtTermSelectG3(Widget w) /* LS3 ESCo */
1730 {
1731     DtTermWidget vtw = (DtTermWidget)w ;
1732     DtTermData vtd =      vtw->vt.td;
1733     DtTermPrimitiveWidget tw         = (DtTermPrimitiveWidget) w;
1734     DtTermPrimData        tpd        = tw->term.tpd;
1735
1736     Debug('P', fprintf(stderr,">>In func _DtTermSelectG3\n")) ;
1737     vtd->GL = &vtd->G3;
1738     vtd->enhFontState = *vtd->GL;
1739     (void)_DtTermPrimBufferSetEnhancement(tpd->termBuffer,
1740             tpd->topRow + tpd->cursorRow, tpd->cursorColumn,
1741             enhFont, vtd->enhFontState);
1742 }
1743
1744 void
1745 _DtTermParseStatus(Widget w)  /* DECID (same as DA)  ESCZ */
1746 {
1747    _DtTermDeviceAttributes(w) ;
1748 }
1749
1750 void
1751 _DtTermSetCharEraseMode(Widget w) /* DECSCA ESCp"q */
1752 {
1753   DtTermWidget vtw = (DtTermWidget) w;
1754   DtTermPrimitiveWidget tw         = (DtTermPrimitiveWidget) w;
1755   DtTermPrimData        tpd        = tw->term.tpd;
1756   ParserContext context ;
1757   Debug('P', fprintf(stderr,">>In func _DtTermSetCharEraseMode\n")) ;
1758   context = GetParserContext(w) ;
1759   STORELASTARG(context) ;
1760   switch ( context->parms[1] ) {
1761      case 0:  /* set back to default which is unprotect  */
1762               /* fall through */
1763      case 2:
1764              vtw->vt.td->enhFieldState = FIELD_UNPROTECT;
1765              (void)_DtTermPrimBufferSetEnhancement(tpd->termBuffer,
1766                       tpd->topRow + tpd->cursorRow, tpd->cursorColumn,
1767                       enhField, vtw->vt.td->enhFieldState);
1768              break;
1769      case 1:
1770              vtw->vt.td->enhFieldState = FIELD_PROTECT;
1771              (void)_DtTermPrimBufferSetEnhancement(tpd->termBuffer,
1772                       tpd->topRow + tpd->cursorRow, tpd->cursorColumn,
1773                       enhField, vtw->vt.td->enhFieldState);
1774              break;
1775    }
1776 }
1777
1778 void
1779 _DtTermSingleWide(Widget w) /* DECSWL ESC#5 */
1780 {
1781   ParserContext context ;
1782   int cnt ;
1783   Debug('P', fprintf(stderr,">>In func _DtTermSingleWide\n")) ;
1784   context = GetParserContext(w) ;
1785 }
1786
1787 void
1788 _DtTermDoubleWide(Widget w) /* DECDWL ESC#6  */
1789 {
1790   ParserContext context ;
1791   int cnt ;
1792   Debug('P', fprintf(stderr,">>In func _DtTermDoubleWide\n")) ;
1793   context = GetParserContext(w) ;
1794 }
1795
1796 void
1797 _DtTermDoubleHigh(Widget w) /* DECWHL ESC#4 */
1798 {
1799   ParserContext context ;
1800   int cnt ;
1801   Debug('P', fprintf(stderr,">>In func _DtTermDoubleHigh\n")) ;
1802   context = GetParserContext(w) ;
1803 }
1804
1805 void
1806 _DtTermParseFontG0(Widget w)
1807 {
1808     DtTermWidget vtw = (DtTermWidget)w ;
1809     DtTermData vtd =      vtw->vt.td;
1810     DtTermPrimitiveWidget tw         = (DtTermPrimitiveWidget) w;
1811     DtTermPrimData        tpd        = tw->term.tpd;
1812     ParserContext context ;
1813     context = GetParserContext(w) ;
1814
1815     Debug('P', fprintf(stderr,">>In func _DtTermParseFontG0\n")) ;
1816     switch (*context->inputChar) {
1817     case 'B':
1818         vtd->G0 = FONT_NORMAL;
1819         break;
1820
1821     case '0':
1822         vtd->G0 = FONT_LINEDRAW;
1823         break;
1824     }
1825
1826     vtd->enhFontState = *vtd->GL;
1827     (void)_DtTermPrimBufferSetEnhancement(tpd->termBuffer,
1828             tpd->topRow + tpd->cursorRow, tpd->cursorColumn,
1829             enhFont, vtd->enhFontState);
1830 }
1831
1832 void
1833 _DtTermParseFontG1(Widget w)
1834 {
1835     DtTermWidget vtw = (DtTermWidget)w ;
1836     DtTermData vtd =      vtw->vt.td;
1837     DtTermPrimitiveWidget tw         = (DtTermPrimitiveWidget) w;
1838     DtTermPrimData        tpd        = tw->term.tpd;
1839     ParserContext context ;
1840     context = GetParserContext(w) ;
1841
1842     Debug('P', fprintf(stderr,">>In func _DtTermParseFontG1\n")) ;
1843     switch (*context->inputChar) {
1844     case 'B':
1845         vtd->G1 = FONT_NORMAL;
1846         break;
1847
1848     case '0':
1849         vtd->G1 = FONT_LINEDRAW;
1850         break;
1851     }
1852
1853     vtd->enhFontState = *vtd->GL;
1854     (void)_DtTermPrimBufferSetEnhancement(tpd->termBuffer,
1855             tpd->topRow + tpd->cursorRow, tpd->cursorColumn,
1856             enhFont, vtd->enhFontState);
1857 }
1858
1859 void
1860 _DtTermParseFontG2(Widget w)
1861 {
1862     DtTermWidget vtw = (DtTermWidget)w ;
1863     DtTermData vtd =      vtw->vt.td;
1864     DtTermPrimitiveWidget tw         = (DtTermPrimitiveWidget) w;
1865     DtTermPrimData        tpd        = tw->term.tpd;
1866     ParserContext context ;
1867     context = GetParserContext(w) ;
1868
1869     Debug('P', fprintf(stderr,">>In func _DtTermParseFontG1\n")) ;
1870     switch (*context->inputChar) {
1871     case 'B':
1872         vtd->G2 = FONT_NORMAL;
1873         break;
1874
1875     case '0':
1876         vtd->G2 = FONT_LINEDRAW;
1877         break;
1878     }
1879
1880     vtd->enhFontState = *vtd->GL;
1881     (void)_DtTermPrimBufferSetEnhancement(tpd->termBuffer,
1882             tpd->topRow + tpd->cursorRow, tpd->cursorColumn,
1883             enhFont, vtd->enhFontState);
1884 }
1885
1886 void
1887 _DtTermParseFontG3(Widget w)
1888 {
1889     DtTermWidget vtw = (DtTermWidget)w ;
1890     DtTermData vtd =      vtw->vt.td;
1891     DtTermPrimitiveWidget tw         = (DtTermPrimitiveWidget) w;
1892     DtTermPrimData        tpd        = tw->term.tpd;
1893     ParserContext context ;
1894     context = GetParserContext(w) ;
1895
1896     Debug('P', fprintf(stderr,">>In func _DtTermParseFontG1\n")) ;
1897     switch (*context->inputChar) {
1898     case 'B':
1899         vtd->G3 = FONT_NORMAL;
1900         break;
1901
1902     case '0':
1903         vtd->G3 = FONT_LINEDRAW;
1904         break;
1905     }
1906
1907     vtd->enhFontState = *vtd->GL;
1908     (void)_DtTermPrimBufferSetEnhancement(tpd->termBuffer,
1909             tpd->topRow + tpd->cursorRow, tpd->cursorColumn,
1910             enhFont, vtd->enhFontState);
1911 }
1912
1913 void
1914 _DtTermParseFontShift(Widget w)  /* Ctrl-E  Ctrl-F  */
1915 {
1916     DtTermWidget vtw = (DtTermWidget)w ;
1917     DtTermData vtd =      vtw->vt.td;
1918     DtTermPrimitiveWidget tw         = (DtTermPrimitiveWidget) w;
1919     DtTermPrimData        tpd        = tw->term.tpd;
1920     ParserContext context ;
1921     context = GetParserContext(w) ;
1922
1923     Debug('P', fprintf(stderr,">>In func _DtTermParseFontShift\n")) ;
1924     switch (*context->inputChar) {
1925     case 'O' & 0x1f:
1926         /* SHIFT OUT */
1927         vtd->GL = &vtd->G0;
1928         break;
1929
1930     case 'N' & 0x1f:
1931         /* SHIFT OUT */
1932         vtd->GL = &vtd->G1;
1933         break;
1934     }
1935
1936     vtd->enhFontState = *vtd->GL;
1937     (void)_DtTermPrimBufferSetEnhancement(tpd->termBuffer,
1938             tpd->topRow + tpd->cursorRow, tpd->cursorColumn,
1939             enhFont, vtd->enhFontState);
1940 }
1941
1942 void
1943 _DtTermParseTab(Widget w)    /* Crtl-I */
1944 {
1945     DtTermWidget vtw = (DtTermWidget)w ;
1946     Debug('P', fprintf(stderr,">>In func _DtTermParseTab\n")) ;
1947     if (vtw->term.tpd->cursorColumn > LASTCOLUMN(vtw)) {
1948         if (vtw->vt.td->fixCursesMode) {
1949             (void) _DtTermNextLine(w);
1950             (void) _DtTermFuncTab(w, 1, fromParser);
1951         } else {
1952             /* we already tabbed to the end of the line, so do nothing... */
1953         }
1954     } else {
1955         (void) _DtTermFuncTab(w, 1, fromParser);
1956     }
1957     return;
1958 }
1959
1960 void
1961 _DtTermParseLF    /* LineFeed (LF) or newline (NL) Ctrl-J,
1962                      Vertical Tab Ctrl-K, Form Feed (NP) Ctrl-L */
1963 (
1964     Widget w
1965 )
1966 {
1967   DtTermWidget vtw = (DtTermWidget)w ;
1968   Debug('P', fprintf(stderr,">>In func _vtParseLR\n")) ;
1969   KILLWRAP(vtw) ;
1970   if (vtw->term.tpd->cursorRow == BOTTOMMARGIN(vtw))
1971    {
1972      /*
1973         ** scroll one line...
1974         */
1975         (void) _DtTermPrimScrollText(w, 1);
1976         vtw->term.tpd->cursorRow = BOTTOMMARGIN(vtw);
1977     }
1978    else {
1979     if (!(vtw->term.tpd->cursorRow == BOTTOMROW(vtw))) {
1980        vtw->term.tpd->cursorRow++ ;
1981      }
1982    }
1983    (void) _DtTermPrimFillScreenGap(w);
1984
1985    if (vtw->term.tpd->autoLineFeed )
1986         _DtTermPrimParseCR(w);
1987 }
1988
1989 void
1990 _DtTermSoftReset   /* DECSTR  ESC!p  */
1991 (
1992     Widget w
1993 )
1994 {
1995   Debug('P', fprintf(stderr,">>In func _DtTermSoftReset\n")) ;
1996    _DtTermFuncSoftReset(w,0 ,fromParser) ;
1997 }
1998
1999 void
2000 _DtTermParseBackspace  /*  Ctrl-H  */
2001 (
2002     Widget w
2003 )
2004 {
2005   ParserContext context ;
2006   DtTermWidget vtw = (DtTermWidget) w;
2007   int row,col,fcol,cnt ;
2008   Debug('P', fprintf(stderr,">>In func  _DtTermParseBackspace\n")) ;
2009   context = GetParserContext(w) ;
2010   fcol = FIRSTCOLUMN(vtw) ;
2011   row = vtw->term.tpd->cursorRow;
2012   col = vtw->term.tpd->cursorColumn;
2013     (void) col--;
2014     if (col<fcol) {
2015       if (vtw->vt.td->reverseWrapMode) {
2016          if ( --row < TOPROW(vtw)) row = BOTTOMROW(vtw);
2017          if (vtw->vt.td->originMode && row < TOPMARGIN(vtw))
2018               row =BOTTOMMARGIN(vtw);
2019          col = LASTCOLUMN(vtw) ;
2020        }
2021       else {
2022          col=fcol;
2023       }
2024     }
2025   vtw->term.tpd->cursorRow = row;
2026   vtw->term.tpd->cursorColumn = col;
2027 }
2028
2029 static void
2030 GetWindowOffsets
2031 (
2032     Widget                        w,
2033     int                          *xOffset,
2034     int                          *yOffset,
2035     int                          *widthOffset,
2036     int                          *heightOffset
2037 )
2038 {
2039     Display                      *display;
2040     Window                        parentReturn;
2041     Window                       *childrenReturn;
2042     unsigned int                  nChildrenReturn;
2043     Window                        rootWindow;
2044     Window                        topWindow;
2045     Window                        childReturn;
2046     int                           destXReturn;
2047     int                           destYReturn;
2048     unsigned int                  widthReturn;
2049     unsigned int                  heightReturn;
2050     unsigned int                  topWidthReturn;
2051     unsigned int                  topHeightReturn;
2052     unsigned int                  borderWidthReturn;
2053     unsigned int                  depthReturn;
2054
2055     *xOffset = 0;
2056     *yOffset = 0;
2057     *widthOffset = 0;
2058     *heightOffset = 0;
2059
2060     if (XmIsMotifWMRunning(w)) {
2061         /* get the window we want to figure the offsets for... */
2062         topWindow = XtWindow(w);
2063
2064         /* and the display involved... */
2065         display = XtDisplay(w);
2066
2067         (void) XQueryTree(display, topWindow, &rootWindow, &parentReturn,
2068                 &childrenReturn, &nChildrenReturn);
2069         (void) XFree(childrenReturn);
2070
2071         /* walk up the tree until the parent window is root... */
2072         while (parentReturn != rootWindow) {
2073             topWindow = parentReturn;
2074             (void) XQueryTree(display, topWindow, &rootWindow,
2075                     &parentReturn, &childrenReturn, &nChildrenReturn);
2076             (void) XFree(childrenReturn);
2077         }
2078
2079         /* we now know what our top window is.  translate our upper
2080          * left corner relative to its upper left corner...
2081          */
2082         (void) XTranslateCoordinates(display, XtWindow(w), topWindow,
2083                 0, 0, &destXReturn, &destYReturn, &childReturn);
2084         *xOffset = destXReturn;
2085         *yOffset = destYReturn;
2086
2087         /* now that we know the top window, we can figure out the size
2088          * difference between the two windows...
2089          */
2090         (void) XGetGeometry(display, topWindow, &rootWindow,
2091                 &destXReturn, &destYReturn, &topWidthReturn,
2092                 &topHeightReturn, &borderWidthReturn, &depthReturn);
2093
2094         (void) XGetGeometry(display, XtWindow(w), &rootWindow,
2095                 &destXReturn, &destYReturn, &widthReturn, &heightReturn,
2096                 &borderWidthReturn, &depthReturn);
2097
2098         *widthOffset = topWidthReturn - widthReturn;
2099         *heightOffset = topHeightReturn - heightReturn;
2100     }
2101 }
2102
2103 void
2104 _DtTermParseSunMisc  /*  Misc sun esc seqs  */
2105 (
2106     Widget w
2107 )
2108 {
2109   ParserContext context ;
2110   DtTermWidget vtw = (DtTermWidget) w;
2111   Display *display = XtDisplay(w);
2112   int i, scr_num = XScreenNumberOfScreen(XtScreen(w));
2113   Window win = XtWindow(w);
2114   Window sh_win;
2115   Widget sw;
2116   XWindowChanges values;
2117   Arg arg[5];
2118   char buf[BUFSIZ];
2119   Position x,y;
2120   short   rows,columns;
2121   Dimension height,width;
2122   char *fmt,*s,*title,*icon;
2123   int xOffset;
2124   int yOffset;
2125   int widthOffset;
2126   int heightOffset;
2127
2128   context = GetParserContext(w) ;
2129   STORELASTARG(context) ;
2130
2131   for (sw = w; !XtIsShell(sw); sw = XtParent(sw));
2132   sh_win = XtWindow(sw) ;
2133   switch (context->parms[1])
2134   {
2135     case 1:
2136       XMapWindow(display,sh_win);
2137       break;
2138     case 2:
2139       XIconifyWindow(display,sh_win,scr_num);
2140       break;
2141     case 3:
2142         (void) GetWindowOffsets(sw, &xOffset, &yOffset, &widthOffset,
2143                 &heightOffset);
2144         /* DKS
2145         (void) XMoveWindow(display, sh_win,
2146                 context->parms[2] + xOffset, context->parms[3] + yOffset);
2147                 DKS */
2148         (void) XtVaSetValues(sw, XmNx, context->parms[2] + xOffset,
2149                 XmNy, context->parms[3] + yOffset, NULL);
2150         break ;
2151     case 4:
2152         (void) GetWindowOffsets(sw, &xOffset, &yOffset, &widthOffset,
2153                 &heightOffset);
2154         (void) XtVaSetValues(sw, XmNwidth, context->parms[3] - widthOffset,
2155                        XmNheight,context->parms[2] - heightOffset, NULL);
2156       break ;
2157     case 5:
2158       XRaiseWindow(display,sh_win);
2159       break ;
2160     case 6:
2161       XLowerWindow(display,sh_win);
2162       break ;
2163     case 7:
2164       _DtTermPrimFuncRedrawDisplay(w, 1, fromParser);
2165       break ;
2166     case 8:
2167         rows = context->parms[2];
2168         columns = context->parms[3];
2169         (void) XtVaSetValues(w, DtNrows, rows, DtNcolumns, columns, NULL);
2170         break ;
2171     case 11:
2172       if (vtw->term.tpd->windowMapped)
2173          sendEscSequence(w,"\033[1t") ;
2174       else
2175          sendEscSequence(w,"\033[2t") ;
2176       break ;
2177     case 13:
2178         (void) GetWindowOffsets(sw, &xOffset, &yOffset, &widthOffset,
2179                 &heightOffset);
2180         (void) XtVaGetValues(sw, XtNx, &x, XtNy, &y, NULL);
2181         (void) sprintf(buf, "\033[3;%d;%dt", x - xOffset, y - yOffset);
2182         (void) sendEscSequence(w, buf);
2183         break;
2184     case 14:
2185         (void) GetWindowOffsets(sw, &xOffset, &yOffset, &widthOffset,
2186                 &heightOffset);
2187         (void) XtVaGetValues(sw, XtNheight, &height, XtNwidth, &width, NULL);
2188         (void) sprintf(buf,"\033[4;%d;%dt", height + heightOffset,
2189                 width + widthOffset);
2190         (void) sendEscSequence(w, buf);
2191         break;
2192     case 18:
2193         (void) XtVaGetValues(w, DtNrows, &rows, DtNcolumns, &columns, NULL);
2194         (void) sprintf(buf, "\033[8;%hd;%hdt", rows, columns);
2195         (void) sendEscSequence(w, buf);
2196         break;
2197     case 20:
2198       XtVaGetValues(sw,XmNiconName, &icon, NULL);
2199       fmt = "\033]L%s\033\\";
2200       if (strlen(icon) + strlen(fmt) + 1 >= sizeof(buf))
2201         s = XtMalloc(strlen(icon) + strlen(fmt) + 1);
2202       else
2203         s = buf;
2204       sprintf(s, "%s", fmt);
2205       sendEscSequence(w,s) ;
2206       if (s != buf) XtFree(s);
2207       break ;
2208     case 21:
2209       XtVaGetValues(sw,XmNtitle, &title, NULL);
2210       fmt = "\033]l%s\033\\";
2211       if (strlen(icon) + strlen(fmt) + 1 >= sizeof(buf))
2212         s = XtMalloc(strlen(icon) + strlen(fmt) + 1);
2213       else
2214         s = buf;
2215       sprintf(s, "%s", fmt);
2216       sendEscSequence(w,s) ;
2217       if (s != buf) XtFree(s);
2218       break ;
2219    }
2220 }
2221
2222 void
2223 _DtTermParserSunWindowIcon( Widget w)   /* sun set icon label */
2224 {
2225   ParserContext context ;
2226   Widget sw;
2227   context = GetParserContext(w) ;
2228   for (sw = w; !XtIsShell(sw); sw = XtParent(sw));
2229   XtVaSetValues(sw, XmNiconName, context->stringParms[0].str, NULL) ;
2230 }
2231
2232 void
2233 _DtTermParserSunWindowTitle     /* Sun set title name */
2234 (
2235 Widget w
2236 )
2237 {
2238   ParserContext context ;
2239   Widget sw;
2240   context = GetParserContext(w) ;
2241   for (sw = w; !XtIsShell(sw); sw = XtParent(sw));
2242   XtVaSetValues(sw,XmNtitle, context->stringParms[0].str, NULL) ;
2243 }
2244
2245 void
2246 _DtTermParserSunIconFile(Widget w)   /* Sun set icon to pixmap in file */
2247 {
2248   DtTermBuffer tb =
2249             (DtTermBuffer)((DtTermPrimitiveWidget)w)->term.tpd->termBuffer ;
2250   ParserContext context ;
2251   int fg, bg;
2252   Widget sw;
2253   Pixmap icon;
2254
2255   context = GetParserContext(w) ;
2256   for (sw = w; !XtIsShell(sw); sw = XtParent(sw));
2257   XtVaGetValues(sw, XtNforeground, &fg, XtNbackground, &bg, NULL);
2258   icon = XmGetPixmap(XtScreen(sw),(char *)context->stringParms[0].str,fg,bg);
2259   if (icon != XmUNSPECIFIED_PIXMAP)
2260      XtVaSetValues(sw, XmNiconPixmap,  icon, NULL);
2261 }
2262