Back to index

lightning-sunbird  0.9+nobinonly
Functions
ltermEscape.c File Reference
#include "lineterm.h"
#include "ltermPrivate.h"

Go to the source code of this file.

Functions

static int ltermProcessCSISequence (struct lterms *lts, const UNICHAR *buf, int count, const UNISTYLE *style, int *consumed, int *opcodes, int *opvals, int *oprow)
 Processes CSI sequence (a special case of Escape sequence processing)
static int ltermProcessDECPrivateMode (struct lterms *lts, const int *paramValues, int paramCount, UNICHAR uch, int *opcodes)
 Processes DEC Private Modes (a special case of CSI sequence processing) ESC [ ? Pm h.
static int ltermProcessXTERMSequence (struct lterms *lts, const UNICHAR *buf, int count, const UNISTYLE *style, int *consumed, int *opcodes)
 Processes XTERM sequence (a special case of Escape sequence processing) ESC ] Ps;Pt BEL.
static int ltermProcessXMLTermSequence (struct lterms *lts, const UNICHAR *buf, int count, const UNISTYLE *style, int *consumed, int *opcodes)
 Processes XMLTerm sequence (a special case of Escape sequence processing) XMLterm escape sequences are of the form ESC { Pm C Pt LF where Pm denotes multiple numeric arguments separated by semicolons, character C is a not a digit and not a semicolon, text parameter Pt may be a null string, and LF is the linefeed character.
int ltermProcessEscape (struct lterms *lts, const UNICHAR *buf, int count, const UNISTYLE *style, int *consumed, int *opcodes, int *opvals, int *oprow)
 Processes ESCAPE sequence in string BUF containing COUNT characters, returning the number of characters CONSUMED and the OPCODES.
int ltermInsDelEraseChar (struct lterms *lts, int count, int action)
 Insert/delete/erase COUNT characters at current output cursor position.
int ltermInsDelEraseLine (struct lterms *lts, int count, int row, int action)
 Insert COUNT blank lines about current current line, scrolling down, or delete COUNT lines at and below current line, scrolling up remaining lines, or erase COUNT lines at and below current line.

Function Documentation

int ltermInsDelEraseChar ( struct lterms lts,
int  count,
int  action 
)

Insert/delete/erase COUNT characters at current output cursor position.

Parameters:
action= LTERM_INSERT_ACTION (insert) LTERM_DELETE_ACTION (delete) LTERM_ERASE_ACTION (erase)
Returns:
0 on success and -1 on error.

Definition at line 1315 of file ltermEscape.c.

{
  struct LtermOutput *lto = &(lts->ltermOutput);
  int charCount = count;
  int j;

  assert(count >= 0);

  LTERM_LOG(ltermInsDelEraseChar,60,("count=%d, action=%d\n",
                 count, action));

  if (lto->outputMode == LTERM2_LINE_MODE) {
    /* Line mode */
    switch (action) {

    case LTERM_INSERT_ACTION:

      if (lto->outputChars + charCount > MAXCOLM1) {
        /* Output buffer overflow; ignore extra inserts */
        LTERM_WARNING("ltermInsDelEraseChar: Warning - output line buffer overflow\n");
        charCount = MAXCOLM1 - lto->outputChars;
      }

      LTERM_LOG(ltermInsDelEraseChar,62,("Line insert %d blank chars\n",
                     charCount));

      /* Shift characters to the right to make room for insertion */
      for (j=lto->outputChars-1; j>=lto->outputCursorChar; j--) {
        lto->outputLine[j+charCount] = lto->outputLine[j];
        lto->outputStyle[j+charCount] = lto->outputStyle[j];
      }

      /* Insert blank characters */
      for (j=lto->outputCursorChar; j<lto->outputCursorChar+charCount; j++) {
        lto->outputLine[j] = U_SPACE;
        lto->outputStyle[j] = LTERM_STDOUT_STYLE | lto->styleMask;
      }

      /* Increment character count */
      lto->outputChars += charCount;
      break;

    case LTERM_DELETE_ACTION:
      if (lto->outputCursorChar+charCount > lto->outputChars)
        charCount = lto->outputChars - lto->outputCursorChar;

      LTERM_LOG(ltermInsDelEraseChar,62,("Line delete %d chars\n",
                     charCount));

      /* Shift characters to the left */
      for (j=lto->outputCursorChar; j<lto->outputChars-charCount; j++) {
        lto->outputLine[j] = lto->outputLine[j+charCount];
        lto->outputStyle[j] = lto->outputStyle[j+charCount];
      }

      /* Decrement character count */
      lto->outputChars -= charCount;
      break;

    case LTERM_ERASE_ACTION:
      if (lto->outputCursorChar+charCount > lto->outputChars)
        charCount = lto->outputChars - lto->outputCursorChar;

      LTERM_LOG(ltermInsDelEraseChar,62,("Line erase %d chars\n",
                     charCount));

      /* Erase characters */
      for (j=lto->outputCursorChar; j<lto->outputCursorChar+charCount; j++) {
        lto->outputLine[j] = U_SPACE;
        lto->outputStyle[j] = LTERM_STDOUT_STYLE | lto->styleMask;
      }

      break;
    }

    /* Note modifications */
    if (lto->outputCursorChar < lto->outputModifiedChar)
      lto->outputModifiedChar = lto->outputCursorChar;

  } else if (lto->outputMode == LTERM1_SCREEN_MODE) {
    /* Screen mode */
    int j0 = lto->cursorRow*lts->nCols;

    switch (action) {

    case LTERM_INSERT_ACTION:
      if (lto->cursorCol+charCount > lts->nCols) {
        /* Ignore inserts beyond screen width */
        LTERM_WARNING("ltermInsDelEraseChar: Warning - screen insert overflow\n");
        charCount = lts->nCols - lto->cursorCol;
      }

      LTERM_LOG(ltermInsDelEraseChar,62,
                ("Screen insert %d blank chars at column %d\n",
                 charCount, lto->cursorCol));

      if (charCount > 0) {
        /* Shift characters to the right to make room for insertion */
        for (j=lts->nCols-1+j0; j>=lto->cursorCol+charCount+j0; j--) {
          lto->screenChar[j] = lto->screenChar[j-charCount];
          lto->screenStyle[j] = lto->screenStyle[j-charCount];
        }

        /* Insert blank characters */
        for (j=lto->cursorCol+j0; j<lto->cursorCol+charCount+j0; j++) {
          lto->screenChar[j] = U_SPACE;
          lto->screenStyle[j] = LTERM_STDOUT_STYLE | lto->styleMask;
        }

        /* Note modified column */
        lto->modifiedCol[lto->cursorRow] = lts->nCols-1;
      }
      break;

    case LTERM_DELETE_ACTION:
      if (lto->cursorCol+charCount > lts->nCols)
        charCount = lts->nCols - lto->cursorCol;

      LTERM_LOG(ltermInsDelEraseChar,62,
                ("Screen delete %d chars at column %d\n",
                 charCount, lto->cursorCol));

      if (charCount > 0) {
        /* Shift characters to the left */
        for (j=lto->cursorCol+j0; j<lts->nCols-charCount+j0; j++) {
          lto->screenChar[j] = lto->screenChar[j+charCount];
          lto->screenStyle[j] = lto->screenStyle[j+charCount];
        }

        /* Note modified column */
        lto->modifiedCol[lto->cursorRow] = lts->nCols-1;
      }

      break;

    case LTERM_ERASE_ACTION:
      if (lto->cursorCol+charCount > lts->nCols)
        charCount = lts->nCols - lto->cursorCol;

      LTERM_LOG(ltermInsDelEraseChar,62,
                ("Screen erase %d chars at column %d\n",
                 charCount, lto->cursorCol));

      if (charCount > 0) {
        /* Erase characters */
        for (j=lto->cursorCol+j0; j<lto->cursorCol+charCount+j0; j++) {
          lto->screenChar[j] = U_SPACE;
          lto->screenStyle[j] = LTERM_STDOUT_STYLE | lto->styleMask;
        }

        /* Note modified column */
        if (lto->modifiedCol[lto->cursorRow] < lto->cursorCol+charCount-1)
          lto->modifiedCol[lto->cursorRow] = lto->cursorCol+charCount-1;
      }

      break;
    }
  }

  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int ltermInsDelEraseLine ( struct lterms lts,
int  count,
int  row,
int  action 
)

Insert COUNT blank lines about current current line, scrolling down, or delete COUNT lines at and below current line, scrolling up remaining lines, or erase COUNT lines at and below current line.

Displayed lines above the current line are unaffected, cursor is not moved and no new modification flags are set.

Parameters:
countno. of lines to be inserted/deleted/erased
rowrow for insertion/deletion/erasure
action= LTERM_INSERT_ACTION (insert) LTERM_DELETE_ACTION (delete) LTERM_ERASE_ACTION (erase)
Returns:
0 on success and -1 on error.

Definition at line 1490 of file ltermEscape.c.

{
  struct LtermOutput *lto = &(lts->ltermOutput);
  int lineCount, kblank1, kblank2;
  int joffset, jscroll, j, k;

  LTERM_LOG(ltermInsDelEraseLine,60, ("count=%d, row=%d, action=%d\n",
                                      count, row, action));

  lineCount = count;

  switch (action) {

  case LTERM_ERASE_ACTION:
    /* Erase lines down; no scrolling */
    if (lineCount > row + 1)
      lineCount = row + 1;

    kblank1 = row-lineCount+1;
    kblank2 = row;
    break;

  case LTERM_INSERT_ACTION:
    /* Scroll down for insertion */
    if ( (row < lto->botScrollRow) ||
         (row > lto->topScrollRow) ) {
      /* Cursor located outside scrollable region */
      return 0;
    }

    if (lineCount > row - lto->botScrollRow + 1)
      lineCount = row - lto->botScrollRow + 1;

    kblank1 = row-lineCount+1;
    kblank2 = row;

    for (k=lto->botScrollRow; k<=row-lineCount; k++) {
      joffset = k*lts->nCols;
      jscroll = lineCount*lts->nCols;

      lto->modifiedCol[k] = lto->modifiedCol[k+lineCount];

      for (j=0+joffset; j<=lts->nCols-1+joffset; j++) {
        lto->screenChar[j] = lto->screenChar[j+jscroll];
        lto->screenStyle[j] = lto->screenStyle[j+jscroll];
      }
    }

    break;

  case LTERM_DELETE_ACTION:
    /* Scroll up for deletion */
    if ( (row < lto->botScrollRow) ||
         (row > lto->topScrollRow) ) {
      /* Cursor located outside scrollable region */
      return 0;
    }

    if (lineCount > row - lto->botScrollRow + 1)
      lineCount = row - lto->botScrollRow + 1;

    kblank1 = lto->botScrollRow;
    kblank2 = lto->botScrollRow + lineCount-1;

    /* Scroll up */
    for (k=row; k>=lto->botScrollRow+lineCount; k--) {
      joffset = k*lts->nCols;
      jscroll = lineCount*lts->nCols;

      lto->modifiedCol[k] = lto->modifiedCol[k-lineCount];

      for (j=0+joffset; j<=lts->nCols-1+joffset; j++) {
        lto->screenChar[j] = lto->screenChar[j-jscroll];
        lto->screenStyle[j] = lto->screenStyle[j-jscroll];
      }
    }

    break;

  default:
    kblank1 = 0;
    kblank2 = -1;
    break;
  }

  /* Blank out lines (assumed to be displayed already) */
  for (k=kblank1; k<=kblank2; k++) {
    joffset = k*lts->nCols;

    lto->modifiedCol[k] = -1;

    for (j=0+joffset; j<=lts->nCols-1+joffset; j++) {
      lto->screenChar[j] = U_SPACE;
      lto->screenStyle[j] = LTERM_STDOUT_STYLE;
    }
  }

  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int ltermProcessCSISequence ( struct lterms lts,
const UNICHAR buf,
int  count,
const UNISTYLE style,
int consumed,
int opcodes,
int opvals,
int oprow 
) [static]

Processes CSI sequence (a special case of Escape sequence processing)

Returns:
0 on success and -1 on error.

Definition at line 242 of file ltermEscape.c.

{
  struct LtermOutput *lto = &(lts->ltermOutput);
  int offset, value, privateMode;
  int paramCount, paramValues[MAXESCAPEPARAMS], param1, param2;

  if (count < 3) {
    /* Incomplete Escape sequence */
    *consumed = 0;
    return 1;
  }

  LTERM_LOG(ltermProcessCSISequence,50,("buf[2]=0x%x, cursorChar=%d, Chars=%d\n",
                buf[2], lto->outputCursorChar, lto->outputChars));

  privateMode = 0;
  offset = 2;
  if (buf[2] == U_QUERYMARK) {
    /* ESC [ ? Process DEC Private Mode */
    privateMode = 1;
    offset = 3;
  }

  /* Process numerical parameters */
  paramCount = 0;
  while ((offset < count) &&
         ((buf[offset] >= (UNICHAR)U_ZERO) &&
          (buf[offset] <= (UNICHAR)U_NINE)) ) {
    /* Starts with a digit */
    value = buf[offset] - U_ZERO;
    offset++;

    /* Process all contiguous digits */
    while ((offset < count) &&
       ((buf[offset] >= (UNICHAR)U_ZERO) &&
        (buf[offset] <= (UNICHAR)U_NINE)) ) {
      value = value * 10 + buf[offset] - U_ZERO;
      offset++;
    }

    if (offset == count) {
      /* Incomplete Escape sequence */
      *consumed = 0;
      return 1;
    }

    if (paramCount < MAXESCAPEPARAMS) {
      /* Store numerical parameter */
      paramValues[paramCount++] = value;

    } else {
      /* Numeric parameter buffer overflow */
      LTERM_WARNING("ltermProcessCSISequence: Warning - numeric parameter buffer overflow\n");
    }

    /* If next character not semicolon, stop processing */
    if (buf[offset] != U_SEMICOLON)
      break;

    /* Process next argument */
    offset++;
  }

  if (offset == count) {
    /* Incomplete Escape sequence */
    *consumed = 0;
    return 1;
  }

  /* Assume that all parsed characters will be consumed at this point */
  *consumed = offset+1;

  LTERM_LOG(ltermProcessCSISequence,51,("paramCount=%d, offset=%d, buf[offset]='%d'\n",
                 paramCount, offset, buf[offset]));

  if (privateMode) {
    /* ESC [ ? Process DEC Private Mode */
    return ltermProcessDECPrivateMode( lts, paramValues, paramCount,
                                       buf[offset], opcodes);
  }

  /* Set returned opcodes to zero */
  *opcodes = 0;

  /* Default parameter values: 1, 1 */
  param1 = (paramCount > 0) ? paramValues[0] : 1;
  param2 = (paramCount > 1) ? paramValues[1] : 1;

  switch (buf[offset]) {

  case U_ATSIGN:    /* Insert Ps (Blank) Character(s) [default: 1] (ICH) */
    if (ltermInsDelEraseChar(lts, param1, LTERM_INSERT_ACTION) != 0)
      return -1;
    return 0;

  case U_e_CHAR:
  case U_A_CHAR:    /* Cursor Up Ps Times [default: 1] (CUU) */
    LTERM_LOG(ltermProcessCSISequence,52,("Cursor Up Count = %d\n", param1));

    if (lto->outputMode == LTERM1_SCREEN_MODE) {
      lto->cursorRow += param1;
      if (lto->cursorRow >= lts->nRows)
        lto->cursorRow = lts->nRows - 1;
    }
    return 0;

  case U_B_CHAR:    /* Cursor Down Ps Times [default: 1] (CUD) */
    LTERM_LOG(ltermProcessCSISequence,52,("Cursor Down Count = %d\n", param1));

    if (lto->outputMode == LTERM1_SCREEN_MODE) {
      lto->cursorRow -= param1;
      if (lto->cursorRow < 0)
        lto->cursorRow = 0;
    }
    return 0;

  case U_a_CHAR:
  case U_C_CHAR:    /* Cursor Forward Ps Times [default: 1] (CUF) */
    LTERM_LOG(ltermProcessCSISequence,52,("Cursor Forward Count = %d\n",
                   param1));

    if (lto->outputMode == LTERM2_LINE_MODE) {

      if (param1 <= (lto->outputChars - lto->outputCursorChar)) {
        lto->outputCursorChar += param1;
      } else {
        lto->outputCursorChar = lto->outputChars;
      }

    } else {
      lto->cursorCol += param1;
      if (lto->cursorCol >= lts->nCols)
        lto->cursorCol = lts->nCols-1;
    }
    return 0;

  case U_D_CHAR:    /* Cursor Backward Ps Times [default: 1] (CUB) */
    LTERM_LOG(ltermProcessCSISequence,52,("Cursor Back Count = %d\n", param1));

    if (lto->outputMode == LTERM2_LINE_MODE) {

      if (param1 <= lto->outputCursorChar) {
        lto->outputCursorChar -= param1;
      } else {
        lto->outputCursorChar = 0;
      }

    } else {
      lto->cursorCol -= param1;
      if (lto->cursorCol < 0)
        lto->cursorCol = 0;
    }
    return 0;

  case U_E_CHAR:    /* Cursor Down Ps Times [default: 1] and to first column */
    LTERM_LOG(ltermProcessCSISequence,52,("Cursor Down and First Count = %d\n",
                   param1));

    if (lto->outputMode == LTERM1_SCREEN_MODE) {
      lto->cursorCol = 0;
      lto->cursorRow -= param1;
      if (lto->cursorRow < 0)
        lto->cursorRow = 0;
    }
    return 0;

  case U_F_CHAR:    /* Cursor Up Ps Times [default: 1] and to first column */
    LTERM_LOG(ltermProcessCSISequence,52,("Cursor Up and First Count = %d\n",
                   param1));

    if (lto->outputMode == LTERM1_SCREEN_MODE) {
      lto->cursorCol = 0;
      lto->cursorRow += param1;
      if (lto->cursorRow >= lts->nRows)
        lto->cursorRow = lts->nRows - 1;
    }
    return 0;

  case U_SNGLQUOTE:
  case U_G_CHAR:    /* Cursor to Column Ps (HPA) */
    LTERM_LOG(ltermProcessCSISequence,52,("Cursor to Column = %d\n", param1));

    if (lto->outputMode == LTERM1_SCREEN_MODE) {
      lto->cursorCol = param1-1;
      if (lto->cursorCol < 0) {
        lto->cursorCol = 0;
      } else if (lto->cursorCol >= lts->nCols) {
        lto->cursorCol = lts->nCols - 1;
      }
    }
    return 0;

  case U_H_CHAR:    /* Cursor Position [row;column] [default: 1;1] (CUP) */
    LTERM_LOG(ltermProcessCSISequence,52,("Cursor Position = (%d, %d)\n",
                   param1, param2));

    if (lto->outputMode == LTERM2_LINE_MODE) {
      /* Line mode */
      if ((param1 > 0) && ((param1-1) <= lto->outputChars)) {
        lto->outputCursorChar = param1-1;
      } else {
        lto->outputCursorChar = 0;
      }

    } else {
      /* Screen mode */
      lto->cursorRow = lts->nRows - param1;
      if (lto->cursorRow < 0) {
        lto->cursorRow = 0;
      } else if (lto->cursorRow >= lts->nRows) {
        lto->cursorRow = lts->nRows - 1;
      }

      lto->cursorCol = param2 - 1;
      if (lto->cursorCol < 0) {
        lto->cursorCol = 0;
      } else if (lto->cursorCol >= lts->nCols) {
        lto->cursorCol = lts->nCols - 1;
      }
    }
    return 0;

  case U_I_CHAR:    /* Move forward Ps tab stops [default: 1] */
    LTERM_LOG(ltermProcessCSISequence,2,("Unimplemented 0x%x\n", buf[offset]));
    return 0;

  case U_J_CHAR:    /* Erase in Display (ED)
                     * Ps = 0 Clear Below (default) 
                     * Ps = 1 Clear Above
                     * Ps = 2 Clear All 
                     */
    param1 = (paramCount > 0) ? paramValues[0] : 0;

    LTERM_LOG(ltermProcessCSISequence,52,("Erase display code %d\n", param1));

    if (lto->outputMode == LTERM2_LINE_MODE) {
      /* Clear line */
      ltermClearOutputLine(lts);

      /* Set opcodes to return incomplete line */
      *opcodes = LTERM_LINEDATA_CODE;

    } else {
      /* Screen mode */
      int eraseLines, j;

      if ((param1 == 0) && (lto->cursorRow == lts->nRows-1))
        param1 = 2;

      switch (param1) {
      case 0:          /* Clear below */
        eraseLines = lto->cursorRow + 1;
        if (ltermInsDelEraseLine(lts, eraseLines, lto->cursorRow, LTERM_ERASE_ACTION) != 0)
          return -1;

        /* Set line modification flags */
        for (j=0; j<=lto->cursorRow; j++) {
          lto->modifiedCol[j] = lts->nCols-1;
        }
        break;

      case 1:          /* Clear above */
        eraseLines = lts->nRows - lto->cursorRow - 1;
        if (ltermInsDelEraseLine(lts, eraseLines, lts->nRows-1, LTERM_ERASE_ACTION) != 0)
          return -1;

        /* Set line modification flags */
        for (j=lto->cursorRow; j<lts->nRows; j++) {
          lto->modifiedCol[j] = lts->nCols-1;
        }
        break;

      case 2:          /* Clear all */
        eraseLines = lts->nRows;
        if (ltermInsDelEraseLine(lts, eraseLines, lts->nRows-1, LTERM_ERASE_ACTION) != 0)
          return -1;

        /* Clear screen */
        *opcodes = LTERM_SCREENDATA_CODE|LTERM_CLEAR_CODE;
        break;

      default:         /* Invalid line erase code */
        LTERM_WARNING("ltermProcessCSISequence: Warning - invalid line erase code %d\n", param1);
      }
    }
    return 0;

  case U_K_CHAR:    /* Erase in Line (EL)
                     * Ps = 0 Clear to Right (default) 
                     * Ps = 1 Clear to Left
                     * Ps = 2 Clear All 
                     */
    param1 = (paramCount > 0) ? paramValues[0] : 0;

    LTERM_LOG(ltermProcessCSISequence,52,("Line erase code %d\n", param1));

    if (lto->outputMode == LTERM2_LINE_MODE) {
      /* Line mode */
      switch(param1) {
      case 0:        /* Clear to Right */
        lto->outputChars = lto->outputCursorChar;
        lto->outputModifiedChar = lto->outputCursorChar;
        break;
      case 1:        /* Clear to Left */
        lto->outputChars -= lto->outputCursorChar;
        lto->outputCursorChar = 0;
        lto->outputModifiedChar = 0;
        break;
      case 2:        /* Clear All */
        lto->outputChars = 0;
        lto->outputCursorChar = 0;
        lto->outputModifiedChar = 0;
        break;
      default:       /* Invalid char erase code */
        LTERM_WARNING("ltermProcessCSISequence: Warning - invalid char erase code %d\n", param1);
      }

    } else {
      /* Screen mode */
      int eraseCount = 0;

      switch(param1) {
      case 0:        /* Clear to Right */
        eraseCount = lts->nCols - lto->cursorCol;
        if (ltermInsDelEraseChar(lts, eraseCount, LTERM_ERASE_ACTION) != 0)
          return -1;
        break;

      case 1:        /* Clear to Left */
        eraseCount = lto->cursorCol;
        lto->cursorCol = 0;
        if (ltermInsDelEraseChar(lts, eraseCount, LTERM_ERASE_ACTION) != 0)
          return -1;
        lto->cursorCol = eraseCount;
        break;

      case 2:        /* Clear All */
        eraseCount = lts->nCols;
        lto->cursorCol = 0;
        if (ltermInsDelEraseChar(lts, eraseCount, LTERM_ERASE_ACTION) != 0)
          return -1;
        lto->cursorCol = eraseCount;
        break;

      default:       /* Invalid erase code */
        LTERM_WARNING("ltermProcessCSISequence: Warning - invalid erase code %d\n", param1);
      }

    }
    return 0;

  case U_L_CHAR:    /* Insert Ps Line(s) [default: 1] (IL) */
    LTERM_LOG(ltermProcessCSISequence,52,("Insert Line Count = %d\n", param1));

    if (lto->outputMode == LTERM1_SCREEN_MODE) {
      if (ltermInsDelEraseLine(lts, param1, lto->cursorRow, LTERM_INSERT_ACTION) != 0)
        return -1;
      *opcodes = LTERM_SCREENDATA_CODE|LTERM_INSERT_CODE;
      *opvals = param1;
      *oprow = lto->cursorRow;
    }
    return 0;

  case U_M_CHAR:    /* Delete Ps Line(s) [default: 1] (DL) */
    LTERM_LOG(ltermProcessCSISequence,52,("Delete Line Count = %d\n", param1));

    if (lto->outputMode == LTERM1_SCREEN_MODE) {
      if (ltermInsDelEraseLine(lts, param1, lto->cursorRow, LTERM_DELETE_ACTION) != 0)
        return -1;
      *opcodes = LTERM_SCREENDATA_CODE|LTERM_DELETE_CODE;
      *opvals = param1;
      *oprow = lto->cursorRow;
    }
    return 0;

  case U_P_CHAR:    /* Delete Ps Character(s) [default: 1] (DCH) */
    if (ltermInsDelEraseChar(lts, param1, LTERM_DELETE_ACTION) != 0)
      return -1;
    return 0;

  case U_T_CHAR:    /* Initiate hilite mouse tracking. Parameters
                     * [func;startx;starty;firstrow;lastrow]. 
                     */
    LTERM_LOG(ltermProcessCSISequence,2,("Unimplemented 0x%x\n", buf[offset]));
    return 0;

  case U_W_CHAR:    /* Tabulator functions:
                     *  Ps = 0  Tab Set (HTS)
                     *  Ps = 2  Tab Clear (TBC), Clear Current Column (default)
                     *  Ps = 5  Tab Clear (TBC), Clear All 
                     */
    LTERM_LOG(ltermProcessCSISequence,2,("Unimplemented 0x%x\n", buf[offset]));
    return 0;

  case U_X_CHAR:    /* Erase Ps Character(s) [default: 1] (ECH) */
    if (ltermInsDelEraseChar(lts, param1, LTERM_ERASE_ACTION) != 0)
      return -1;
    return 0;

  case U_Z_CHAR:    /* Move backward Ps [default: 1] tab stops */
    LTERM_LOG(ltermProcessCSISequence,2,("Unimplemented 0x%x\n", buf[offset]));
    return 0;

  case U_c_CHAR:    /* Send Device Attributes (DA)
                     * Ps = 0 (or omitted) : request attributes from terminal 
                     * returns: ESC[?1;2c
                     *          (``I am a VT100 with Advanced Video Option'') 
                     */
    LTERM_LOG(ltermProcessCSISequence,52,("Device Attr %d\n", param1));
    {
      char deviceAttr[] = "\033[?1;2c";
      if (ltermSendChar(lts, deviceAttr, strlen(deviceAttr)) != 0)
        return -1;
    }

    return 0;

  case U_d_CHAR:    /* Cursor to Line Ps (VPA) */
    LTERM_LOG(ltermProcessCSISequence,52,("Cursor to Line = %d\n", param1));
    if (lto->outputMode == LTERM1_SCREEN_MODE) {
      lto->cursorRow = lts->nRows - param1;
      if (lto->cursorRow < 0) {
        lto->cursorRow = 0;
      } else if (lto->cursorRow >= lts->nRows) {
        lto->cursorRow = lts->nRows - 1;
      }
    }
    return 0;

  case U_f_CHAR:    /* Horizontal and Vertical Position [row;column] (HVP)
                     * [default: 1;1]
                     */
    LTERM_LOG(ltermProcessCSISequence,2,("Unimplemented 0x%x\n", buf[offset]));
    return 0;

  case U_g_CHAR:    /* Tab Clear (TBC) 
                     * Ps = 0 Clear Current Column (default) 
                     * Ps = 3 Clear All (TBC)
                     */
    LTERM_LOG(ltermProcessCSISequence,2,("Unimplemented 0x%x\n", buf[offset]));
    return 0;

  case U_i_CHAR:    /* Printing 
                     * Ps = 4 disable transparent print mode (MC4) 
                     * Ps = 5 enable transparent print mode (MC5)
                     */
    LTERM_LOG(ltermProcessCSISequence,2,("Unimplemented 0x%x\n", buf[offset]));
    return 0;

  case U_h_CHAR:    /* Set Mode (SM)
                     * Ps =  4 Insert Mode (SMIR)
                     * Ps = 20 Automatic Newline (LNM)
                     */
    LTERM_LOG(ltermProcessCSISequence,52,("Set Mode %d\n", param1));

    if (param1 == 4) {
      lto->insertMode = 1;
    } else if (param1 == 4) {
      lto->automaticNewline = 1;
    } if ((param1 % 100) == 47) {
      /* Switch to alternate buffer */
      if (lto->outputMode == LTERM2_LINE_MODE) {
        ltermSwitchToScreenMode(lts);
        *opcodes = LTERM_LINEDATA_CODE | LTERM_OUTPUT_CODE;
      }
    }
    return 0;

  case U_l_CHAR:    /* Reset Mode (RM)
                     * Ps =  4 Replace Mode (RMIR)
                     * Ps = 20 Normal Linefeed (LNM)
                     */
    LTERM_LOG(ltermProcessCSISequence,52,("Reset Mode %d\n", param1));

    if (param1 == 4) {
      lto->insertMode = 0;
    } else if (param1 == 4) {
      lto->automaticNewline = 0;
    } if ((param1 % 100) == 47) {
      /* Switch to regular buffer */
      if (lto->outputMode == LTERM1_SCREEN_MODE) {
        ltermSwitchToLineMode(lts);
        *opcodes = LTERM_SCREENDATA_CODE | LTERM_CLEAR_CODE;
      }
    }
    return 0;

  case U_m_CHAR:    /* Character Attributes (SGR) 
                     * Ps = 0 Normal (default) 
                     * Ps = 1 / 22 On / Off Bold (bright fg) 
                     * Ps = 4 / 24 On / Off Underline 
                     * Ps = 5 / 25 On / Off Blink (bright bg) 
                     * Ps = 7 / 27 On / Off Inverse 
                     * Ps = 30 / 40 fg/bg Black 
                     * Ps = 31 / 41 fg/bg Red 
                     * Ps = 32 / 42 fg/bg Green 
                     * Ps = 33 / 43 fg/bg Yellow 
                     * Ps = 34 / 44 fg/bg Blue 
                     * Ps = 35 / 45 fg/bg Magenta 
                     * Ps = 36 / 46 fg/bg Cyan 
                     * Ps = 37 / 47 fg/bg White 
                     * Ps = 39 / 49 fg/bg Default
                     */

    /* Enforce default value for parameter (hack!) */
    if (paramCount == 0)
      param1 = 0;

    LTERM_LOG(ltermProcessCSISequence,52,("Character Attr %d\n", param1));
    switch (param1) {
    case 0:
      lto->styleMask = 0;
      break;
    case 1:
      lto->styleMask |= LTERM_BOLD_STYLE;
      break;
    case 22:
      lto->styleMask &= ~LTERM_BOLD_STYLE;
      break;
    case 4:
      lto->styleMask |= LTERM_ULINE_STYLE;
      break;
    case 24:
      lto->styleMask &= ~LTERM_ULINE_STYLE;
      break;
    case 5:
      lto->styleMask |= LTERM_BLINK_STYLE;
      break;
    case 25:
      lto->styleMask &= ~LTERM_BLINK_STYLE;
      break;
    case 7:
      lto->styleMask |= LTERM_INVERSE_STYLE;
      break;
    case 27:
      lto->styleMask &= ~LTERM_INVERSE_STYLE;
      break;
    default:
      break;
    }
    return 0;

  case U_n_CHAR:    /* Device Status Report (DSR) 
                     * Ps = 5 Status Report ESC [ 0 n (``OK'') 
                     * Ps = 6 Report Cursor Position (CPR) [row;column]
                     *         as ESC [ r ; c R 
                     * Ps = 7 Request Display Name 
                     * Ps = 8 Request Version Number (place in window title)
                     */
    LTERM_LOG(ltermProcessCSISequence,52,("Status Report %d\n", param1));
    switch (param1) {
    case 5:
      {
        char statusReport[] = "\033[01";
        if (ltermSendChar(lts, statusReport, strlen(statusReport)) != 0)
          return -1;
      }
      break;

    case 6:
      if (lto->outputMode == LTERM1_SCREEN_MODE) {
        int iRow = lts->nRows-lto->cursorRow;
        int iCol = lto->cursorCol+1;
        char cursorPos[13];

        if ((iRow > 0) && (iRow < 10000) && (iCol > 0) && (iCol < 10000)) {
          if (sprintf(cursorPos, "\033[%d;%dR", iRow, iCol) > 12) {
            LTERM_ERROR("ltermProcessCSISequence: Error - DSR buffer overflow\n");
          }
          if (ltermSendChar(lts, cursorPos, strlen(cursorPos)) != 0)
            return -1;
        }
      }
      break;
    default:
      break;
    }
    return 0;

  case U_r_CHAR:    /* Set Scrolling Region [top;bottom] 
                     * [default: full size of window] (CSR) 
                     */

    if (lto->outputMode == LTERM1_SCREEN_MODE) {

      if (paramCount == 0) {
        param1 = 1;
        param2 = lts->nRows;
      }

      LTERM_LOG(ltermProcessCSISequence,52,("Scrolling Region (%d, %d)\n",
                                            param1, param2));

      lto->topScrollRow = (param1 > 0) ? lts->nRows - param1 : lts->nRows - 1;
      if (lto->topScrollRow < 0)
        lto->topScrollRow = 0;

      lto->botScrollRow = (param2 > 0) ? lts->nRows - param2 : lts->nRows - 1;
      if (lto->botScrollRow < 0)
        lto->botScrollRow = 0;

      if (lto->topScrollRow < lto->botScrollRow) {
        int temRow = lto->topScrollRow;
        lto->topScrollRow = lto->botScrollRow;
        lto->botScrollRow = temRow;
      }

      *opcodes = LTERM_SCREENDATA_CODE|LTERM_SCROLL_CODE;
      *opvals = lto->topScrollRow;
      *oprow = lto->botScrollRow;
    }

    return 0;

  case U_x_CHAR:    /* Request Terminal Parameters (DECREQTPARM) */
    LTERM_LOG(ltermProcessCSISequence,2,("Unimplemented 0x%x\n", buf[offset]));
    return 0;

  default:          /* Unknown Escape sequence */
    LTERM_WARNING("ltermProcessCSISequence: Warning - unknown sequence 0x%x\n",
                  buf[offset]);
    return 0;
  }

}

Here is the call graph for this function:

Here is the caller graph for this function:

static int ltermProcessDECPrivateMode ( struct lterms lts,
const int paramValues,
int  paramCount,
UNICHAR  uch,
int opcodes 
) [static]

Processes DEC Private Modes (a special case of CSI sequence processing) ESC [ ? Pm h.

Returns:
0 on success and -1 on error.

Definition at line 876 of file ltermEscape.c.

{
  struct LtermOutput *lto = &(lts->ltermOutput);
  int param1, param2;

  LTERM_LOG(ltermProcessDECPrivateMode,50,("ch=0x%x, cursorChar=%d, Chars=%d\n",
                uch, lto->outputCursorChar, lto->outputChars));

  /* Set returned opcodes to zero */
  *opcodes = 0;

  /* Default parameter values: 1, 1 */
  param1 = (paramCount > 0) ? paramValues[0] : 1;
  param2 = (paramCount > 1) ? paramValues[1] : 1;

  switch (uch) {
  case U_h_CHAR:    /* DEC Private Mode Set (DECSET) */
    LTERM_LOG(ltermProcessDECPrivateMode,2,("Unimplemented 0x%x\n", uch));
    if ((param1 % 100) == 47) {
      /* Switch to screen mode */
      if (lto->outputMode == LTERM2_LINE_MODE) {
        ltermSwitchToScreenMode(lts);
        *opcodes = LTERM_LINEDATA_CODE | LTERM_OUTPUT_CODE;
      }
    }
    return 0;

  case U_l_CHAR:    /* DEC Private Mode Reset (DECRST) */
    LTERM_LOG(ltermProcessDECPrivateMode,2,("Unimplemented 0x%x\n", uch));
    if ((param1 % 100) == 47) {
      /* Switch to line mode */
      if (lto->outputMode == LTERM1_SCREEN_MODE) {
        ltermSwitchToLineMode(lts);
        *opcodes = LTERM_SCREENDATA_CODE | LTERM_CLEAR_CODE;
      }
    }
    return 0;

  case U_r_CHAR:    /* Restore previously saved DEC Private Mode Values */
    LTERM_LOG(ltermProcessDECPrivateMode,2,("Unimplemented 0x%x\n", uch));
    return 0;

  case U_s_CHAR:    /* Save DEC Private Mode Values */
    LTERM_LOG(ltermProcessDECPrivateMode,2,("Unimplemented 0x%x\n", uch));
    return 0;

  case U_t_CHAR:    /* Toggle DEC Private Mode Values */
    LTERM_LOG(ltermProcessDECPrivateMode,2,("Unimplemented 0x%x\n", uch));
    return 0;

  default:          /* Unknown escape sequence */
    LTERM_WARNING("ltermProcessDECPrivateMode: Warning - unknown sequence 0x%x\n",
                  uch);
    return 0;
  }

}

Here is the call graph for this function:

Here is the caller graph for this function:

int ltermProcessEscape ( struct lterms lts,
const UNICHAR buf,
int  count,
const UNISTYLE style,
int consumed,
int opcodes,
int opvals,
int oprow 
)

Processes ESCAPE sequence in string BUF containing COUNT characters, returning the number of characters CONSUMED and the OPCODES.

Using Extended Backus-Naur Form notation: OPCODES ::= 0 if the sequence was processed without any change of outputMode or terminating condition. OPCODES ::= LINEDATA OUTPUT if a switch from LineMode to ScreenMode or StreamMode was triggered by the ESCAPE sqeuence. OPCODES ::= SCREENDATA ( CLEAR | INSERT | DELETE | SCROLL )? for screenMode escape sequences or if a switch from ScreenMode to StreamMode was triggered by the ESCAPE sequence. (A switch from ScreenMode to LineMode is not considered a terminating condition and occurs transparently.) OPVALS contains return value(s) for specific screen operations such as INSERT, DELETE, and SCROLL. OPROW contains the row value for specific screen operations such as INSERT, DELETE, and SCROLL (or -1, cursor row is to be used).

OPVALS contains return value(s) for specific screen operations such as INSERT and DELETE. OPROW contains the row value for specific screen operations such as INSERT and DELETE (or -1, cursor row is to be used).

Returns:
0 on successful processing of the ESCAPE sequence, 1 if BUF contains an incomplete ESCAPE sequence, -1 if error an error occurred.

Definition at line 85 of file ltermEscape.c.

{
  struct LtermOutput *lto = &(lts->ltermOutput);

  LTERM_LOG(ltermProcessEscape,50,("count=%d, buf[1]=0x%x, cursorChar=%d, Chars=%d\n",
                count, buf[1], lto->outputCursorChar, lto->outputChars));

  if (count < 2) {
    /* Incomplete Escape sequence */
    *consumed = 0;
    return 1;
  }

  if (buf[1] == U_LBRACKET) {
    /* ESC [ Process CSI sequence */
    return ltermProcessCSISequence(lts, buf, count, style, consumed,
                                   opcodes, opvals, oprow);
  }

  if (buf[1] == U_RBRACKET) {
    /* ESC ] Process XTERM sequence */
    return ltermProcessXTERMSequence(lts, buf, count, style, consumed,
                                     opcodes);
  }

  if (buf[1] == U_LCURLY) {
    /* ESC { Process XMLTerm sequence */
    return ltermProcessXMLTermSequence(lts, buf, count, style, consumed,
                                       opcodes);
  }

  /* Assume two characters will be consumed at this point */
  *consumed = 2;

  switch (buf[1]) {

  /* Three character sequences */
  case U_NUMBER:            /* ESC # 8 DEC Screen Alignment Test */
  case U_LPAREN:            /* ESC ( C Designate G0 Character Set */
  case U_RPAREN:            /* ESC ) C Designate G1 Character Set */
  case U_STAR:              /* ESC * C Designate G2 Character Set */
  case U_PLUS:              /* ESC + C Designate G3 Character Set */
  case U_DOLLAR:            /* ESC $ C Designate Kanji Character Set */
    LTERM_LOG(ltermProcessEscape,51,("3 char sequence, buf[1:2]=0x%x,0x%x\n",
                  buf[1], buf[2]));

    if (count < 3) {
      /* Incomplete Escape sequence */
      *consumed = 0;
      return 1;
    }
    *consumed = 3;

    if (buf[1] == U_NUMBER) {
      /* ESC # 8 DEC Screen Alignment Test */
    } else {
      /* ESC ()*+$ C Designate Character Set */
    }
    return 0;

  /* Two character sequences */
  case U_SEVEN:             /* ESC 7 Save Cursor */
    LTERM_LOG(ltermProcessEscape,2,("Unimplemented 0x%x\n", buf[1]));
    return 0;

  case U_EIGHT:             /* ESC 8 Restore Cursor */
    LTERM_LOG(ltermProcessEscape,2,("Unimplemented 0x%x\n", buf[1]));
    return 0;

  case U_EQUALS:            /* ESC = Application Keypad */
    LTERM_LOG(ltermProcessEscape,52,("Application Keypad\n"));
    if (lto->outputMode == LTERM2_LINE_MODE) {
      ltermSwitchToScreenMode(lts);
      *opcodes = LTERM_LINEDATA_CODE | LTERM_OUTPUT_CODE;
    }
    return 0;

  case U_GREATERTHAN:       /* ESC > Normal Keypad */
    LTERM_LOG(ltermProcessEscape,52,("Normal Keypad\n"));
    if (lto->outputMode == LTERM1_SCREEN_MODE) {
      ltermSwitchToLineMode(lts);
      *opcodes = LTERM_SCREENDATA_CODE | LTERM_CLEAR_CODE;
    }
    return 0;

  case U_D_CHAR:            /* ESC D Index (IND) */
    LTERM_LOG(ltermProcessEscape,52,("Index\n"));
    if (lto->outputMode == LTERM1_SCREEN_MODE) {
      /* Scroll up */
      if (ltermInsDelEraseLine(lts, 1, lto->topScrollRow, LTERM_DELETE_ACTION) != 0)
        return -1;
      *opcodes = LTERM_SCREENDATA_CODE | LTERM_DELETE_CODE;
      *opvals = 1;
      *oprow = lto->topScrollRow;
    }
    return 0;

  case U_E_CHAR:            /* ESC E Next Line (NEL) */
    if (lto->outputMode == LTERM1_SCREEN_MODE) {
      if (lto->cursorRow > 0)
        lto->cursorRow--;
    }
    return 0;

  case U_H_CHAR:            /* ESC H Tab Set (HTS) */
    LTERM_LOG(ltermProcessEscape,2,("Unimplemented 0x%x\n", buf[1]));
    return 0;

  case U_M_CHAR:            /* ESC M Reverse Index (TI) */
    LTERM_LOG(ltermProcessEscape,52,("Reverse Index\n"));
    if (lto->outputMode == LTERM1_SCREEN_MODE) {
      /* Scroll down */
      if (ltermInsDelEraseLine(lts, 1, lto->topScrollRow, LTERM_INSERT_ACTION) != 0)
        return -1;
      *opcodes = LTERM_SCREENDATA_CODE | LTERM_INSERT_CODE;
      *opvals = 1;
      *oprow = lto->topScrollRow;
    }
    return 0;

  case U_N_CHAR:            /* ESC N Single Shift Select of G2 Character Set */
    LTERM_LOG(ltermProcessEscape,2,("Unimplemented 0x%x\n", buf[1]));
    return 0;

  case U_O_CHAR:            /* ESC O Single Shift Select of G3 Character Set */
    LTERM_LOG(ltermProcessEscape,2,("Unimplemented 0x%x\n", buf[1]));
    return 0;

  case U_Z_CHAR:            /* ESC Z Obsolete form of ESC[c */
    LTERM_LOG(ltermProcessEscape,2,("Unimplemented 0x%x\n", buf[1]));
    return 0;

  case U_c_CHAR:            /* ESC c Full reset (RIS)  */
    LTERM_LOG(ltermProcessEscape,2,("Unimplemented 0x%x\n", buf[1]));
    return 0;

  case U_n_CHAR:            /* ESC n Invoke the G2 Character Set  */
    LTERM_LOG(ltermProcessEscape,2,("Unimplemented 0x%x\n", buf[1]));
    return 0;

  case U_o_CHAR:            /* ESC o Invoke the G3 Character Set */
    LTERM_LOG(ltermProcessEscape,2,("Unimplemented 0x%x\n", buf[1]));
    return 0;

  default:
    LTERM_WARNING("ltermProcessEscape: Warning - unknown sequence 0x%x\n",
                  buf[1]);
    return 0;
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int ltermProcessXMLTermSequence ( struct lterms lts,
const UNICHAR buf,
int  count,
const UNISTYLE style,
int consumed,
int opcodes 
) [static]

Processes XMLTerm sequence (a special case of Escape sequence processing) XMLterm escape sequences are of the form ESC { Pm C Pt LF where Pm denotes multiple numeric arguments separated by semicolons, character C is a not a digit and not a semicolon, text parameter Pt may be a null string, and LF is the linefeed character.

Omitted numeric parameters are assumed to be zero. Any carriage return character preceding the terminating LF is discarded.

Returns:
0 on success and -1 on error.

Definition at line 1033 of file ltermEscape.c.

{
  struct LtermOutput *lto = &(lts->ltermOutput);
  int offset, value, strLength;
  int paramCount, paramValues[MAXESCAPEPARAMS], param1, param2, param3;
  UNICHAR termChar, paramString[MAXSTRINGPARAM+1];
  char paramCString[MAXSTRINGPARAM+1];

  if (count < 4) {
    /* Incomplete Escape sequence */
    *consumed = 0;
    return 1;
  }

  LTERM_LOG(ltermProcessXMLTermSequence,50,("cursorChar=%d, Chars=%d\n",
                lto->outputCursorChar, lto->outputChars));

  offset = 2;

  /* Set returned opcodes to zero */
  *opcodes = 0;

  /* Process numerical parameters */
  paramCount = 0;
  while ((offset < count) &&
         ((buf[offset] >= (UNICHAR)U_ZERO) &&
          (buf[offset] <= (UNICHAR)U_NINE)) ) {
    /* Starts with a digit */
    value = buf[offset] - U_ZERO;
    offset++;

    /* Process all contiguous digits */
    while ((offset < count) &&
           ((buf[offset] >= (UNICHAR)U_ZERO) &&
            (buf[offset] <= (UNICHAR)U_NINE)) ) {
      value = value * 10 + buf[offset] - U_ZERO;
      offset++;
    }

    if (offset == count) {
      /* Incomplete Escape sequence */
      *consumed = 0;
      return 1;
    }

    if (paramCount < MAXESCAPEPARAMS) {
      /* Store numerical parameter */
      paramValues[paramCount++] = value;

    } else {
      /* Numeric parameter buffer overflow */
      LTERM_WARNING("ltermProcessXMLTermSequence: Warning - numeric parameter buffer overflow\n");
    }

    /* If next character not semicolon, stop processing */
    if (buf[offset] != U_SEMICOLON)
      break;

    /* Process next argument */
    offset++;
  }

  if (offset == count) {
    /* Incomplete Escape sequence */
    *consumed = 0;
    return 1;
  }

  /* Terminating character */
  termChar = buf[offset];

  /* Skip terminating character */
  offset++;

  LTERM_LOG(ltermProcessXMLTermSequence,51,("paramCount=%d, offset=%d, termChar=0x%x\n",
                 paramCount, offset, termChar));

  /* Process string parameter */
  strLength = 0;
  while ((offset < count) && (buf[offset] != U_LINEFEED)) {
    if (strLength < MAXSTRINGPARAM) {
      paramCString[strLength] = buf[offset];
      paramString[strLength++] = buf[offset];
      offset++;

    } else {
      LTERM_WARNING("ltermProcessXMLTermSequence: Warning - string parameter too long; truncated\n");
      break;
    }
  }

  if (offset == count) {
    /* Incomplete Escape sequence */
    *consumed = 0;
    return 1;
  }

  /* Discard any CR character preceding the terminating LF character */
  if ((strLength > 0) && (paramString[strLength-1] == U_CRETURN))
    strLength--;

  /* Insert terminating NULL character in string */
  paramCString[strLength] = U_NUL;
  paramString[strLength] = U_NUL;

  LTERM_LOGUNICODE(ltermProcessXMLTermSequence,52,(paramString, strLength));

  /* All parsed characters have been consumed at this point (including BEL) */
  *consumed = offset+1;

  /* Default parameter values: 0, 0, 0 */
  param1 = (paramCount > 0) ? paramValues[0] : 0;
  param2 = (paramCount > 1) ? paramValues[1] : 0;
  param3 = (paramCount > 2) ? paramValues[2] : 0;

  switch (termChar) {
    int streamOpcodes, nRows, nCols, sprint_len;
    char sprint_buf[81];

  case U_A_CHAR:    /* Send XMLterm device attributes */
  case U_B_CHAR:    /* Send XMLterm device attributes (Bourne shell format) */
  case U_C_CHAR:    /* Send XMLterm device attributes (C shell format) */
    LTERM_LOG(ltermProcessXMLTermSequence,52,("Sending device attributes\n"));


    nRows = lts->nRows;
    nCols = lts->nCols;

    if ((nRows >= 0) && (nRows < 10000) && (nCols >= 0) && (nCols < 10000)) {

      if (termChar == U_C_CHAR) {
        /* C shell format */

        sprint_len = sprintf(sprint_buf, "setenv LINES %d;setenv COLUMNS %d;setenv LTERM_COOKIE ", nRows, nCols);

      } else {

        sprint_len = sprintf(sprint_buf, "LINES=%d;COLUMNS=%d;LTERM_COOKIE=", nRows, nCols);
      }

      if (sprint_len > 80) {
        LTERM_ERROR("ltermProcessXMLTermSequence: Error - sprintf buffer overflow\n");
      }

      if (ltermSendChar(lts, sprint_buf, strlen(sprint_buf)) != 0)
        return -1;
    }

    if (*lts->cookie) {
      if (ltermSendChar(lts, lts->cookie, strlen(lts->cookie)) != 0)
        return -1;
    }

    if (termChar == U_B_CHAR) {
      const char exportStr[] = ";export LINES COLUMNS LTERM_COOKIE";
      if (ltermSendChar(lts, exportStr, strlen(exportStr)) != 0)
        return -1;
    }

    if (ltermSendChar(lts, "\n", 1) != 0)
      return -1;
    return 0;

  case U_D_CHAR:    /* Set debugging messageLevel/search-string */
    LTERM_LOG(ltermProcessXMLTermSequence,52,("Setting message level etc.\n"));
    if (strLength == 0) {
      tlog_set_level(param1, param2, NULL);
    } else {
      tlog_set_level(param1, param2, paramCString);
    }
    return 0;

  case U_E_CHAR:    /* Enable/disable input echo setting */
    if (param1) {
      /* Enable input echo */
      lts->disabledInputEcho = 0;

      LTERM_LOG(ltermProcessXMLTermSequence,52,("Enabled input echo\n"));
    } else {
      /* Disable input echo */
      lts->disabledInputEcho = 1;

      LTERM_LOG(ltermProcessXMLTermSequence,52,("Disabled input echo\n"));
    }
    return 0;

  case U_F_CHAR:    /* Enable/disable full screen mode */
    if (param1) {
      /* Enable full screen mode */
      if (lto->outputMode == LTERM2_LINE_MODE) {
        ltermSwitchToScreenMode(lts);
        *opcodes = LTERM_LINEDATA_CODE | LTERM_OUTPUT_CODE;
      }

      LTERM_LOG(ltermProcessXMLTermSequence,52,("Enabled full screen mode\n"));

    } else {
      /* Disable full screen mode */
      if (lto->outputMode == LTERM1_SCREEN_MODE) {
        ltermSwitchToLineMode(lts);
        *opcodes = LTERM_SCREENDATA_CODE | LTERM_CLEAR_CODE;
      }

      LTERM_LOG(ltermProcessXMLTermSequence,52,("Disabled full screen mode\n"));
    }
    return 0;

  case U_R_CHAR:    /* Enable/disable raw input mode */
    if (param1) {
      /* Switch to raw input mode */
      ltermSwitchToRawMode(lts);

      LTERM_LOG(ltermProcessXMLTermSequence,52,("Raw input mode\n"));

    } else {
      /* Switch to regular input mode */
      ltermClearInputLine(lts);

      LTERM_LOG(ltermProcessXMLTermSequence,52,("Line input mode\n"));
    }
    return 0;

  case U_J_CHAR:    /* Switch to null-terminated Javascript stream mode */
  case U_S_CHAR:    /* Switch to null-terminated stream mode, with cookie */

    if (lto->outputMode == LTERM1_SCREEN_MODE) {
      *opcodes = LTERM_SCREENDATA_CODE;
    } else if (lto->outputMode == LTERM2_LINE_MODE) {
      *opcodes = LTERM_LINEDATA_CODE | LTERM_OUTPUT_CODE;
    }

    assert(lto->outputMode != LTERM0_STREAM_MODE);

    /* Set stream codes */
    streamOpcodes = 0;

    if (termChar == U_J_CHAR) {
      /* Javascript stream */
      streamOpcodes |= LTERM_JSSTREAM_CODE;

    } else {
      /* HTML/XML stream */
      if (param1)
        streamOpcodes |= LTERM_DOCSTREAM_CODE;

      if (param2)
        streamOpcodes |= LTERM_XMLSTREAM_CODE;

      if (param3)
        streamOpcodes |= LTERM_WINSTREAM_CODE;
    }

    /* Check if cookie matches */
    if ((strLength > 0) && (strcmp(paramCString, lts->cookie) == 0)) {
      streamOpcodes |= LTERM_COOKIESTR_CODE;
    }

    LTERM_LOG(ltermProcessXMLTermSequence,52,
              ("Switching to stream mode, codes=0x%x\n", streamOpcodes));

    if (0 != ltermSwitchToStreamMode(lts, streamOpcodes, NULL))
      return -1;

    return 0;

  default:          /* Unknown escape sequence */
    LTERM_WARNING("ltermProcessXMLTermSequence: Warning - unknown sequence 0x%x\n",
                   termChar);
    return 0;
  }

  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int ltermProcessXTERMSequence ( struct lterms lts,
const UNICHAR buf,
int  count,
const UNISTYLE style,
int consumed,
int opcodes 
) [static]

Processes XTERM sequence (a special case of Escape sequence processing) ESC ] Ps;Pt BEL.

Returns:
0 on success and -1 on error.

Definition at line 940 of file ltermEscape.c.

{
  struct LtermOutput *lto = &(lts->ltermOutput);
  int offset, paramValue, strLength;
  UNICHAR paramString[MAXSTRINGPARAM+1];

  if (count < 3) {
    /* Incomplete Escape sequence */
    *consumed = 0;
    return 1;
  }

  LTERM_LOG(ltermProcessXTERMSequence,50,("cursorChar=%d, Chars=%d\n",
                lto->outputCursorChar, lto->outputChars));

  offset = 2;

  /* Set returned opcodes to zero */
  *opcodes = 0;

  /* Process numerical parameter */
  paramValue = 0;
  while ((offset < count) &&
         ((buf[offset] >= (UNICHAR)U_ZERO) &&
          (buf[offset] <= (UNICHAR)U_NINE)) ) {
    paramValue = paramValue * 10 + buf[offset] - U_ZERO;
    offset++;
  }

  if (offset == count) {
    /* Incomplete Escape sequence */
    *consumed = 0;
    return 1;
  }

  if (buf[offset] != U_SEMICOLON) {
    /* If next character not semicolon, return */
    *consumed = offset;
    return 0;
  }

  LTERM_LOG(ltermProcessXTERMSequence,51,("paramValue=%d, offset=%d, buf[offset]=0x%x\n",
                 paramValue, offset, buf[offset]));

  /* Skip the semicolon */
  offset++;

  /* Process string parameter */
  strLength = 0;
  while ((offset < count) && (buf[offset] != U_BEL)) {
    if (strLength < MAXSTRINGPARAM) {
      paramString[strLength++] = buf[offset];
      offset++;

    } else {
      LTERM_WARNING("ltermProcessXTERMSequence: Warning - string parameter too long; truncated\n");
      break;
    }
  }

  if (offset == count) {
    /* Incomplete Escape sequence */
    *consumed = 0;
    return 1;
  }

  /* Insert terminating NULL character in string */
  paramString[strLength] = U_NUL;

  LTERM_LOGUNICODE(ltermProcessXTERMSequence,52,(paramString, strLength));

  /* All parsed characters have been consumed at this point */
  *consumed = offset+1;

  LTERM_WARNING("ltermProcessXTERMSequence: Warning - unimplemented 0x%x\n",
                buf[offset]);

  return 0;
}

Here is the caller graph for this function: