cde/lib/DtTerm/Term/TermParse.c

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