Пример #1
0
/// Overwrite the current redo and cursor characters + left adjust
///
/// @param c
static void put_curr_and_l_to_X(char_u c)
{
  int tempc;

  if (curwin->w_p_rl && p_ri) {
    return;
  }

  if ((curwin->w_cursor.col < (colnr_T)STRLEN(get_cursor_line_ptr()))) {
    if (!p_ri || curwin->w_cursor.col) {
      if (p_ri) {
        dec_cursor();
      } else {
        inc_cursor();
      }

      if (F_is_TyC_TyD((tempc = gchar_cursor()))) {
        pchar_cursor(toF_TyB(tempc));
        AppendCharToRedobuff(K_BS);
        AppendCharToRedobuff(tempc);
      }

      if (p_ri) {
        inc_cursor();
      } else {
        dec_cursor();
      }
    }
  }

  put_and_redo(c);
}
Пример #2
0
// When extra == 0: Return true if the cursor is before or on the first
// non-blank in the line.
// When extra == 1: Return true if the cursor is before the first non-blank in
// the line.
int inindent(int extra)
{
  char_u      *ptr;
  colnr_T col;

  for (col = 0, ptr = get_cursor_line_ptr(); vim_iswhite(*ptr); ++col) {
    ptr++;
  }

  if (col >= curwin->w_cursor.col + extra) {
    return true;
  } else {
    return false;
  }
}
Пример #3
0
/// Change the character left to the cursor to a X or _X type
static void chg_l_toXor_X(void)
{
  char_u tempc;

  if ((curwin->w_cursor.col != 0)
      && (curwin->w_cursor.col + 1 == (colnr_T)STRLEN(get_cursor_line_ptr()))) {
    return;
  }

  if (!curwin->w_cursor.col && p_ri) {
    return;
  }

  if (p_ri) {
    dec_cursor();
  } else {
    inc_cursor();
  }

  switch (gchar_cursor()) {
    case ALEF_     : tempc = ALEF     ; break;
    case ALEF_U_H_ : tempc = ALEF_U_H ; break;
    case _AYN_     : tempc = _AYN     ; break;
    case AYN_      : tempc = AYN      ; break;
    case _GHAYN_   : tempc = _GHAYN   ; break;
    case GHAYN_    : tempc = GHAYN    ; break;
    case _HE_      : tempc = _HE      ; break;
    case YE_       : tempc = YE       ; break;
    case IE_       : tempc = IE       ; break;
    case TEE_      : tempc = TEE      ; break;
    case YEE_      : tempc = YEE      ; break;
    default        : tempc = 0        ;
  }

  if (tempc) {
    put_and_redo(tempc);
  }

  if (p_ri) {
    inc_cursor();
  } else {
    dec_cursor();
  }
}
Пример #4
0
/// Change the char. under the cursor to a _X_ or _X type
static void chg_c_to_X_or_X(void)
{
  int tempc;

  tempc = gchar_cursor();

  if (curwin->w_cursor.col + 1 < (colnr_T)STRLEN(get_cursor_line_ptr())) {
    inc_cursor();
    if ((tempc == F_HE) && (F_is_TyB_TyC_TyD(SRC_EDT, AT_CURSOR))) {
      tempc = _HE_;
      dec_cursor();
      put_and_redo((char_u)tempc);
      return;
    }
    dec_cursor();
  }

  if ((tempc = toF_Xor_X_(tempc)) != 0) {
    put_and_redo((char_u)tempc);
  }
}
Пример #5
0
// Set the indent of the current line.
// Leaves the cursor on the first non-blank in the line.
// Caller must take care of undo.
// "flags":
//  SIN_CHANGED:    call changed_bytes() if the line was changed.
//  SIN_INSERT: insert the indent in front of the line.
//  SIN_UNDO:   save line for undo before changing it.
//  @param size measured in spaces
// Returns true if the line was changed.
int set_indent(int size, int flags)
{
  char_u *p;
  char_u *newline;
  char_u *oldline;
  char_u *s;
  int todo;
  int ind_len;  // Measured in characters.
  int line_len;
  int doit = false;
  int ind_done = 0;  // Measured in spaces.
  int tab_pad;
  int retval = false;

  // Number of initial whitespace chars when 'et' and 'pi' are both set.
  int orig_char_len = -1;

  // First check if there is anything to do and compute the number of
  // characters needed for the indent.
  todo = size;
  ind_len = 0;
  p = oldline = get_cursor_line_ptr();

  // Calculate the buffer size for the new indent, and check to see if it
  // isn't already set.
  // If 'expandtab' isn't set: use TABs; if both 'expandtab' and
  // 'preserveindent' are set count the number of characters at the
  // beginning of the line to be copied.
  if (!curbuf->b_p_et || (!(flags & SIN_INSERT) && curbuf->b_p_pi)) {
    // If 'preserveindent' is set then reuse as much as possible of
    // the existing indent structure for the new indent.
    if (!(flags & SIN_INSERT) && curbuf->b_p_pi) {
      ind_done = 0;

      // Count as many characters as we can use.
      while (todo > 0 && vim_iswhite(*p)) {
        if (*p == TAB) {
          tab_pad = (int)curbuf->b_p_ts - (ind_done % (int)curbuf->b_p_ts);

          // Stop if this tab will overshoot the target.
          if (todo < tab_pad) {
            break;
          }
          todo -= tab_pad;
          ind_len++;
          ind_done += tab_pad;
        } else {
          todo--;
          ind_len++;
          ind_done++;
        }
        p++;
      }

      // Set initial number of whitespace chars to copy if we are
      // preserving indent but expandtab is set.
      if (curbuf->b_p_et) {
        orig_char_len = ind_len;
      }

      // Fill to next tabstop with a tab, if possible.
      tab_pad = (int)curbuf->b_p_ts - (ind_done % (int)curbuf->b_p_ts);

      if ((todo >= tab_pad) && (orig_char_len == -1)) {
        doit = true;
        todo -= tab_pad;
        ind_len++;

        // ind_done += tab_pad;
      }
    }

    // Count tabs required for indent.
    while (todo >= (int)curbuf->b_p_ts) {
      if (*p != TAB) {
        doit = true;
      } else {
        p++;
      }
      todo -= (int)curbuf->b_p_ts;
      ind_len++;

      // ind_done += (int)curbuf->b_p_ts;
    }
  }

  // Count spaces required for indent.
  while (todo > 0) {
    if (*p != ' ') {
      doit = true;
    } else {
      p++;
    }
    todo--;
    ind_len++;

    // ind_done++;
  }

  // Return if the indent is OK already.
  if (!doit && !vim_iswhite(*p) && !(flags & SIN_INSERT)) {
    return false;
  }

  // Allocate memory for the new line.
  if (flags & SIN_INSERT) {
    p = oldline;
  } else {
    p = skipwhite(p);
  }
  line_len = (int)STRLEN(p) + 1;

  // If 'preserveindent' and 'expandtab' are both set keep the original
  // characters and allocate accordingly.  We will fill the rest with spaces
  // after the if (!curbuf->b_p_et) below.
  if (orig_char_len != -1) {
    newline = xmalloc(orig_char_len + size - ind_done + line_len);
    todo = size - ind_done;

    // Set total length of indent in characters, which may have been
    // undercounted until now.
    ind_len = orig_char_len + todo;
    p = oldline;
    s = newline;

    while (orig_char_len > 0) {
      *s++ = *p++;
      orig_char_len--;
    }

    // Skip over any additional white space (useful when newindent is less
    // than old).
    while (vim_iswhite(*p)) {
      p++;
    }
  } else {
    todo = size;
    newline = xmalloc(ind_len + line_len);
    s = newline;
  }

  // Put the characters in the new line.
  // if 'expandtab' isn't set: use TABs
  if (!curbuf->b_p_et) {
    // If 'preserveindent' is set then reuse as much as possible of
    // the existing indent structure for the new indent.
    if (!(flags & SIN_INSERT) && curbuf->b_p_pi) {
      p = oldline;
      ind_done = 0;

      while (todo > 0 && vim_iswhite(*p)) {
        if (*p == TAB) {
          tab_pad = (int)curbuf->b_p_ts - (ind_done % (int)curbuf->b_p_ts);

          // Stop if this tab will overshoot the target.
          if (todo < tab_pad) {
            break;
          }
          todo -= tab_pad;
          ind_done += tab_pad;
        } else {
          todo--;
          ind_done++;
        }
        *s++ = *p++;
      }

      // Fill to next tabstop with a tab, if possible.
      tab_pad = (int)curbuf->b_p_ts - (ind_done % (int)curbuf->b_p_ts);

      if (todo >= tab_pad) {
        *s++ = TAB;
        todo -= tab_pad;
      }
      p = skipwhite(p);
    }

    while (todo >= (int)curbuf->b_p_ts) {
      *s++ = TAB;
      todo -= (int)curbuf->b_p_ts;
    }
  }

  while (todo > 0) {
    *s++ = ' ';
    todo--;
  }
  memmove(s, p, (size_t)line_len);

  // Replace the line (unless undo fails).
  if (!(flags & SIN_UNDO) || (u_savesub(curwin->w_cursor.lnum) == OK)) {
    ml_replace(curwin->w_cursor.lnum, newline, false);

    if (flags & SIN_CHANGED) {
      changed_bytes(curwin->w_cursor.lnum, 0);
    }

    // Correct saved cursor position if it is in this line.
    if (saved_cursor.lnum == curwin->w_cursor.lnum) {
      if (saved_cursor.col >= (colnr_T)(p - oldline)) {
        // Cursor was after the indent, adjust for the number of
        // bytes added/removed.
        saved_cursor.col += ind_len - (colnr_T)(p - oldline);

      } else if (saved_cursor.col >= (colnr_T)(s - newline)) {
        // Cursor was in the indent, and is now after it, put it back
        // at the start of the indent (replacing spaces with TAB).
        saved_cursor.col = (colnr_T)(s - newline);
      }
    }
    retval = true;
  } else {
    free(newline);
  }
  curwin->w_cursor.col = ind_len;
  return retval;
}
Пример #6
0
// TODO(unknown):
// Findmatch() should be adapted for lisp, also to make showmatch
// work correctly: now (v5.3) it seems all C/C++ oriented:
// - it does not recognize the #\( and #\) notations as character literals
// - it doesn't know about comments starting with a semicolon
// - it incorrectly interprets '(' as a character literal
// All this messes up get_lisp_indent in some rare cases.
// Update from Sergey Khorev:
// I tried to fix the first two issues.
int get_lisp_indent(void)
{
  pos_T *pos, realpos, paren;
  int amount;
  char_u *that;
  colnr_T col;
  colnr_T firsttry;
  int parencount;
  int quotecount;
  int vi_lisp;

  // Set vi_lisp to use the vi-compatible method.
  vi_lisp = (vim_strchr(p_cpo, CPO_LISP) != NULL);

  realpos = curwin->w_cursor;
  curwin->w_cursor.col = 0;

  if ((pos = findmatch(NULL, '(')) == NULL) {
    pos = findmatch(NULL, '[');
  } else {
    paren = *pos;
    pos = findmatch(NULL, '[');

    if ((pos == NULL) || ltp(pos, &paren)) {
      pos = &paren;
    }
  }

  if (pos != NULL) {
    // Extra trick: Take the indent of the first previous non-white
    // line that is at the same () level.
    amount = -1;
    parencount = 0;

    while (--curwin->w_cursor.lnum >= pos->lnum) {
      if (linewhite(curwin->w_cursor.lnum)) {
        continue;
      }

      for (that = get_cursor_line_ptr(); *that != NUL; ++that) {
        if (*that == ';') {
          while (*(that + 1) != NUL) {
            that++;
          }
          continue;
        }

        if (*that == '\\') {
          if (*(that + 1) != NUL) {
            that++;
          }
          continue;
        }

        if ((*that == '"') && (*(that + 1) != NUL)) {
          while (*++that && *that != '"') {
            // Skipping escaped characters in the string
            if (*that == '\\') {
              if (*++that == NUL) {
                break;
              }
              if (that[1] == NUL) {
                that++;
                break;
              }
            }
          }
        }
        if ((*that == '(') || (*that == '[')) {
          parencount++;
        } else if ((*that == ')') || (*that == ']')) {
          parencount--;
        }
      }

      if (parencount == 0) {
        amount = get_indent();
        break;
      }
    }

    if (amount == -1) {
      curwin->w_cursor.lnum = pos->lnum;
      curwin->w_cursor.col = pos->col;
      col = pos->col;

      that = get_cursor_line_ptr();

      if (vi_lisp && (get_indent() == 0)) {
        amount = 2;
      } else {
        char_u *line = that;

        amount = 0;

        while (*that && col) {
          amount += lbr_chartabsize_adv(line, &that, (colnr_T)amount);
          col--;
        }

        // Some keywords require "body" indenting rules (the
        // non-standard-lisp ones are Scheme special forms):
        // (let ((a 1))    instead    (let ((a 1))
        //   (...))       of       (...))
        if (!vi_lisp && ((*that == '(') || (*that == '['))
            && lisp_match(that + 1)) {
          amount += 2;
        } else {
          that++;
          amount++;
          firsttry = amount;

          while (vim_iswhite(*that)) {
            amount += lbr_chartabsize(line, that, (colnr_T)amount);
            that++;
          }

          if (*that && (*that != ';')) {
            // Not a comment line.
            // Test *that != '(' to accommodate first let/do
            // argument if it is more than one line.
            if (!vi_lisp && (*that != '(') && (*that != '[')) {
              firsttry++;
            }

            parencount = 0;
            quotecount = 0;

            if (vi_lisp || ((*that != '"') && (*that != '\'')
                && (*that != '#') && ((*that < '0') || (*that > '9')))) {
              while (*that && (!vim_iswhite(*that) || quotecount || parencount)
                     && (!((*that == '(' || *that == '[')
                     && !quotecount && !parencount && vi_lisp))) {
                if (*that == '"') {
                  quotecount = !quotecount;
                }
                if (((*that == '(') || (*that == '[')) && !quotecount) {
                  parencount++;
                }
                if (((*that == ')') || (*that == ']')) && !quotecount) {
                  parencount--;
                }
                if ((*that == '\\') && (*(that + 1) != NUL)) {
                  amount += lbr_chartabsize_adv(line, &that, (colnr_T)amount);
                }

                amount += lbr_chartabsize_adv(line, &that, (colnr_T)amount);
              }
            }

            while (vim_iswhite(*that)) {
              amount += lbr_chartabsize(line, that, (colnr_T)amount);
              that++;
            }

            if (!*that || (*that == ';')) {
              amount = firsttry;
            }
          }
        }
      }
    }
  } else {
    amount = 0;  // No matching '(' or '[' found, use zero indent.
  }
  curwin->w_cursor = realpos;

  return amount;
}
Пример #7
0
// Copy the indent from ptr to the current line (and fill to size).
// Leaves the cursor on the first non-blank in the line.
// @return true if the line was changed.
int copy_indent(int size, char_u *src)
{
  char_u *p = NULL;
  char_u *line = NULL;
  char_u *s;
  int todo;
  int ind_len;
  int line_len = 0;
  int tab_pad;
  int ind_done;
  int round;

  // Round 1: compute the number of characters needed for the indent
  // Round 2: copy the characters.
  for (round = 1; round <= 2; ++round) {
    todo = size;
    ind_len = 0;
    ind_done = 0;
    s = src;

    // Count/copy the usable portion of the source line.
    while (todo > 0 && vim_iswhite(*s)) {
      if (*s == TAB) {
        tab_pad = (int)curbuf->b_p_ts
                  - (ind_done % (int)curbuf->b_p_ts);

        // Stop if this tab will overshoot the target.
        if (todo < tab_pad) {
          break;
        }
        todo -= tab_pad;
        ind_done += tab_pad;
      } else {
        todo--;
        ind_done++;
      }
      ind_len++;

      if (p != NULL) {
        *p++ = *s;
      }
      s++;
    }

    // Fill to next tabstop with a tab, if possible.
    tab_pad = (int)curbuf->b_p_ts - (ind_done % (int)curbuf->b_p_ts);

    if ((todo >= tab_pad) && !curbuf->b_p_et) {
      todo -= tab_pad;
      ind_len++;

      if (p != NULL) {
        *p++ = TAB;
      }
    }

    // Add tabs required for indent.
    while (todo >= (int)curbuf->b_p_ts && !curbuf->b_p_et) {
      todo -= (int)curbuf->b_p_ts;
      ind_len++;

      if (p != NULL) {
        *p++ = TAB;
      }
    }

    // Count/add spaces required for indent.
    while (todo > 0) {
      todo--;
      ind_len++;

      if (p != NULL) {
        *p++ = ' ';
      }
    }

    if (p == NULL) {
      // Allocate memory for the result: the copied indent, new indent
      // and the rest of the line.
      line_len = (int)STRLEN(get_cursor_line_ptr()) + 1;
      line = xmalloc(ind_len + line_len);
      p = line;
    }
  }

  // Append the original line
  memmove(p, get_cursor_line_ptr(), (size_t)line_len);

  // Replace the line
  ml_replace(curwin->w_cursor.lnum, line, false);

  // Put the cursor after the indent.
  curwin->w_cursor.col = ind_len;
  return true;
}
Пример #8
0
// Count the size (in window cells) of the indent in the current line.
int get_indent(void)
{
  return get_indent_str(get_cursor_line_ptr(), (int)curbuf->b_p_ts, false);
}
Пример #9
0
/// Convert the given Farsi character into a _X or _X_ type
///
/// @param c The character to convert.
///
/// @return Farsi character converted to a _X or _X_ type.
static char_u toF_Xor_X_(int c)
{
  char_u tempc;

  switch (c) {
    case BE     : tempc = _BE     ; break;
    case PE     : tempc = _PE     ; break;
    case TE     : tempc = _TE     ; break;
    case SE     : tempc = _SE     ; break;
    case JIM    : tempc = _JIM    ; break;
    case CHE    : tempc = _CHE    ; break;
    case HE_J   : tempc = _HE_J   ; break;
    case XE     : tempc = _XE     ; break;
    case SIN    : tempc = _SIN    ; break;
    case SHIN   : tempc = _SHIN   ; break;
    case SAD    : tempc = _SAD    ; break;
    case ZAD    : tempc = _ZAD    ; break;
    case AYN    : tempc = _AYN    ; break;
    case AYN_   : tempc = _AYN_   ; break;
    case GHAYN  : tempc = _GHAYN  ; break;
    case GHAYN_ : tempc = _GHAYN_ ; break;
    case FE     : tempc = _FE     ; break;
    case GHAF   : tempc = _GHAF   ; break;
    case KAF    : tempc = _KAF    ; break;
    case GAF    : tempc = _GAF    ; break;
    case LAM    : tempc = _LAM    ; break;
    case MIM    : tempc = _MIM    ; break;
    case NOON   : tempc = _NOON   ; break;
    case YE     :
    case YE_    : tempc = _YE     ; break;
    case YEE    :
    case YEE_   : tempc = _YEE    ; break;
    case IE     :
    case IE_    : tempc = _IE     ; break;
    case F_HE   :
      tempc = _HE;

      if (p_ri
          && (curwin->w_cursor.col + 1
              < (colnr_T)STRLEN(get_cursor_line_ptr()))) {
        inc_cursor();
        if (F_is_TyB_TyC_TyD(SRC_EDT, AT_CURSOR)) {
          tempc = _HE_;
        }
        dec_cursor();
      }

      if (!p_ri && STRLEN(get_cursor_line_ptr())) {
        dec_cursor();
        if (F_is_TyB_TyC_TyD(SRC_EDT, AT_CURSOR)) {
          tempc = _HE_;
        }
        inc_cursor();
      }

      break;

    default:
      tempc = 0;
  }

  return tempc;
}
Пример #10
0
/// Map Farsi keyboard when in fkmap mode.
int fkmap(int c)
{
  int tempc;
  static int revins;

  if (IS_SPECIAL(c)) {
    return c;
  }

  if (ascii_isdigit(c)
      || ((c == '.'
           || c == '+'
           || c == '-'
           || c == '^'
           || c == '%'
           || c == '#'
           || c == '=')
          && revins)) {
    if (!revins) {
      if (curwin->w_cursor.col) {
        if (!p_ri) {
          dec_cursor();
        }

        chg_c_toX_orX();
        chg_l_toXor_X();
        if (!p_ri) {
          inc_cursor();
        }
      }
    }

    arrow_used = TRUE;
    (void)stop_arrow();

    if (!curwin->w_p_rl && revins) {
      inc_cursor();
    }

    revins++;
    p_ri = 1;
  } else {
    if (revins) {
      arrow_used = TRUE;
      (void)stop_arrow();

      revins = 0;
      if (curwin->w_p_rl) {
        while ((F_isdigit(gchar_cursor())
                || (gchar_cursor() == F_PERIOD
                    || gchar_cursor() == F_PLUS
                    || gchar_cursor() == F_MINUS
                    || gchar_cursor() == F_MUL
                    || gchar_cursor() == F_DIVIDE
                    || gchar_cursor() == F_PERCENT
                    || gchar_cursor() == F_EQUALS))
                && gchar_cursor() != NUL) {
          curwin->w_cursor.col++;
        }
      } else {
        if (curwin->w_cursor.col) {
          while ((F_isdigit(gchar_cursor())
                 || (gchar_cursor() == F_PERIOD
                     || gchar_cursor() == F_PLUS
                     || gchar_cursor() == F_MINUS
                     || gchar_cursor() == F_MUL
                     || gchar_cursor() == F_DIVIDE
                     || gchar_cursor() == F_PERCENT
                     || gchar_cursor() == F_EQUALS))
                 && --curwin->w_cursor.col) {
          }
        }

        if (!F_isdigit(gchar_cursor())) {
          ++curwin->w_cursor.col;
        }
      }
    }
  }

  if (!revins) {
    if (curwin->w_p_rl) {
      p_ri = 0;
    }

    if (!curwin->w_p_rl) {
      p_ri = 1;
    }
  }

  if ((c < 0x100)
      && (isalpha(c)
          || (c == '&')
          || (c == '^')
          || (c == ';')
          || (c == '\'')
          || (c == ',')
          || (c == '[')
          || (c == ']')
          || (c == '{')
          || (c == '}'))) {
    chg_r_to_Xor_X_();
  }

  tempc = 0;
  switch (c) {
    case '`':
    case ' ':
    case '.':
    case '!':
    case '"':
    case '$':
    case '%':
    case '^':
    case '&':
    case '/':
    case '(':
    case ')':
    case '=':
    case '\\':
    case '?':
    case '+':
    case '-':
    case '_':
    case '*':
    case ':':
    case '#':
    case '~':
    case '@':
    case '<':
    case '>':
    case '{':
    case '}':
    case '|':
    case '0':
    case '1':
    case '2':
    case '3':
    case '4':
    case '5':
    case '6':
    case '7':
    case '8':
    case '9':
    case 'B':
    case 'E':
    case 'F':
    case 'H':
    case 'I':
    case 'K':
    case 'L':
    case 'M':
    case 'O':
    case 'P':
    case 'Q':
    case 'R':
    case 'T':
    case 'U':
    case 'W':
    case 'Y':
    case  NL:
    case  TAB:
      if (p_ri && (c == NL) && curwin->w_cursor.col) {
        // If the char before the cursor is _X_ or X_ do not change
        // the one under the cursor with X type.

        dec_cursor();
        if (F_isalpha(gchar_cursor())) {
          inc_cursor();
          return NL;
        }
        inc_cursor();
      }

      if (!p_ri) {
        if (!curwin->w_cursor.col) {
          switch (c) {
            case '0'  : return FARSI_0     ;
            case '1'  : return FARSI_1     ;
            case '2'  : return FARSI_2     ;
            case '3'  : return FARSI_3     ;
            case '4'  : return FARSI_4     ;
            case '5'  : return FARSI_5     ;
            case '6'  : return FARSI_6     ;
            case '7'  : return FARSI_7     ;
            case '8'  : return FARSI_8     ;
            case '9'  : return FARSI_9     ;
            case 'B'  : return F_PSP       ;
            case 'E'  : return JAZR_N      ;
            case 'F'  : return ALEF_D_H    ;
            case 'H'  : return ALEF_A      ;
            case 'I'  : return TASH        ;
            case 'K'  : return F_LQUOT     ;
            case 'L'  : return F_RQUOT     ;
            case 'M'  : return HAMZE       ;
            case 'O'  : return '['         ;
            case 'P'  : return ']'         ;
            case 'Q'  : return OO          ;
            case 'R'  : return MAD_N       ;
            case 'T'  : return OW          ;
            case 'U'  : return MAD         ;
            case 'W'  : return OW_OW       ;
            case 'Y'  : return JAZR        ;
            case '`'  : return F_PCN       ;
            case '!'  : return F_EXCL      ;
            case '@'  : return F_COMMA     ;
            case '#'  : return F_DIVIDE    ;
            case '$'  : return F_CURRENCY  ;
            case '%'  : return F_PERCENT   ;
            case '^'  : return F_MUL       ;
            case '&'  : return F_BCOMMA    ;
            case '*'  : return F_STAR      ;
            case '('  : return F_LPARENT   ;
            case ')'  : return F_RPARENT   ;
            case '-'  : return F_MINUS     ;
            case '_'  : return F_UNDERLINE ;
            case '='  : return F_EQUALS    ;
            case '+'  : return F_PLUS      ;
            case '\\' : return F_BSLASH    ;
            case '|'  : return F_PIPE      ;
            case ':'  : return F_DCOLON    ;
            case '"'  : return F_SEMICOLON ;
            case '.'  : return F_PERIOD    ;
            case '/'  : return F_SLASH     ;
            case '<'  : return F_LESS      ;
            case '>'  : return F_GREATER   ;
            case '?'  : return F_QUESTION  ;
            case ' '  : return F_BLANK     ;
          }
          break;
        }
      }

      if (!p_ri) {
        dec_cursor();
      }

      switch ((tempc = gchar_cursor())) {
        case _BE:
        case _PE:
        case _TE:
        case _SE:
        case _JIM:
        case _CHE:
        case _HE_J:
        case _XE:
        case _SIN:
        case _SHIN:
        case _SAD:
        case _ZAD:
        case _FE:
        case _GHAF:
        case _KAF:
        case _KAF_H:
        case _GAF:
        case _LAM:
        case _MIM:
        case _NOON:
        case _HE:
        case _HE_:
        case _TA:
        case _ZA:
          put_curr_and_l_to_X(toF_TyA((char_u)tempc));
          break;

        case _AYN:
        case _AYN_:
          if (!p_ri) {
            if (!curwin->w_cursor.col) {
              put_curr_and_l_to_X(AYN);
              break;
            }
          }

          if (p_ri) {
            inc_cursor();
          } else {
            dec_cursor();
          }

          if (F_is_TyB_TyC_TyD(SRC_EDT, AT_CURSOR)) {
            tempc = AYN_;
          } else {
            tempc = AYN;
          }

          if (p_ri) {
            dec_cursor();
          } else {
            inc_cursor();
          }

          put_curr_and_l_to_X((char_u)tempc);
          break;

        case _GHAYN:
        case _GHAYN_:

          if (!p_ri) {
            if (!curwin->w_cursor.col) {
              put_curr_and_l_to_X(GHAYN);
              break;
            }
          }

          if (p_ri) {
            inc_cursor();
          } else {
            dec_cursor();
          }

          if (F_is_TyB_TyC_TyD(SRC_EDT, AT_CURSOR)) {
            tempc = GHAYN_;
          } else {
            tempc = GHAYN;
          }

          if (p_ri) {
            dec_cursor();
          } else {
            inc_cursor();
          }

          put_curr_and_l_to_X((char_u)tempc);
          break;

        case _YE:
        case _IE:
        case _YEE:

          if (!p_ri) {
            if (!curwin->w_cursor.col) {
              put_curr_and_l_to_X(
                  (tempc == _YE ? YE : tempc == _IE ? IE : YEE));
              break;
            }
          }

          if (p_ri) {
            inc_cursor();
          } else {
            dec_cursor();
          }

          if (F_is_TyB_TyC_TyD(SRC_EDT, AT_CURSOR)) {
            tempc = (tempc == _YE ? YE_ : tempc == _IE ? IE_ : YEE_);
          } else {
            tempc = (tempc == _YE ? YE : tempc == _IE ? IE : YEE);
          }

          if (p_ri) {
            dec_cursor();
          } else {
            inc_cursor();
          }

          put_curr_and_l_to_X((char_u)tempc);
          break;
      }

      if (!p_ri) {
        inc_cursor();
      }

      tempc = 0;

      switch (c) {
        case '0'  : return FARSI_0     ;
        case '1'  : return FARSI_1     ;
        case '2'  : return FARSI_2     ;
        case '3'  : return FARSI_3     ;
        case '4'  : return FARSI_4     ;
        case '5'  : return FARSI_5     ;
        case '6'  : return FARSI_6     ;
        case '7'  : return FARSI_7     ;
        case '8'  : return FARSI_8     ;
        case '9'  : return FARSI_9     ;
        case 'B'  : return F_PSP       ;
        case 'E'  : return JAZR_N      ;
        case 'F'  : return ALEF_D_H    ;
        case 'H'  : return ALEF_A      ;
        case 'I'  : return TASH        ;
        case 'K'  : return F_LQUOT     ;
        case 'L'  : return F_RQUOT     ;
        case 'M'  : return HAMZE       ;
        case 'O'  : return '['         ;
        case 'P'  : return ']'         ;
        case 'Q'  : return OO          ;
        case 'R'  : return MAD_N       ;
        case 'T'  : return OW          ;
        case 'U'  : return MAD         ;
        case 'W'  : return OW_OW       ;
        case 'Y'  : return JAZR        ;
        case '`'  : return F_PCN       ;
        case '!'  : return F_EXCL      ;
        case '@'  : return F_COMMA     ;
        case '#'  : return F_DIVIDE    ;
        case '$'  : return F_CURRENCY  ;
        case '%'  : return F_PERCENT   ;
        case '^'  : return F_MUL       ;
        case '&'  : return F_BCOMMA    ;
        case '*'  : return F_STAR      ;
        case '('  : return F_LPARENT   ;
        case ')'  : return F_RPARENT   ;
        case '-'  : return F_MINUS     ;
        case '_'  : return F_UNDERLINE ;
        case '='  : return F_EQUALS    ;
        case '+'  : return F_PLUS      ;
        case '\\' : return F_BSLASH    ;
        case '|'  : return F_PIPE      ;
        case ':'  : return F_DCOLON    ;
        case '"'  : return F_SEMICOLON ;
        case '.'  : return F_PERIOD    ;
        case '/'  : return F_SLASH     ;
        case '<'  : return F_LESS      ;
        case '>'  : return F_GREATER   ;
        case '?'  : return F_QUESTION  ;
        case ' '  : return F_BLANK     ;
      }
      break;

    case 'a' : tempc = _SHIN ; break;
    case 'A' : tempc = WAW_H ; break;
    case 'b' : tempc = ZAL   ; break;
    case 'c' : tempc = ZE    ; break;
    case 'C' : tempc = JE    ; break;
    case 'd' : tempc = _YE   ; break;
    case 'D' : tempc = _YEE  ; break;
    case 'e' : tempc = _SE   ; break;
    case 'f' : tempc = _BE   ; break;
    case 'g' : tempc = _LAM  ; break;

    case 'G':
      if (!curwin->w_cursor.col && STRLEN(get_cursor_line_ptr())) {
        if (gchar_cursor() == _LAM) {
          chg_c_toX_orX();
        } else if (p_ri) {
          chg_c_to_X_or_X();
        }
      }

      if (!p_ri) {
        if (!curwin->w_cursor.col) {
          return ALEF_U_H;
        }
        dec_cursor();
      }

      if (gchar_cursor() == _LAM) {
        chg_c_toX_orX();
        chg_l_toXor_X();
        tempc = ALEF_U_H;
      } else if (F_is_TyB_TyC_TyD(SRC_EDT, AT_CURSOR)) {
        tempc = ALEF_U_H_;
        chg_l_toXor_X();
      } else {
        tempc = ALEF_U_H;
      }

      if (!p_ri) {
        inc_cursor();
      }

      return tempc;

    case 'h':
      if (!curwin->w_cursor.col && STRLEN(get_cursor_line_ptr())) {
        if (p_ri) {
          chg_c_to_X_or_X();
        }
      }

      if (!p_ri) {
        if (!curwin->w_cursor.col) {
          return ALEF;
        }
        dec_cursor();
      }

      if (gchar_cursor() == _LAM) {
        chg_l_toXor_X();
        del_char(FALSE);
        AppendCharToRedobuff(K_BS);

        if (!p_ri) {
          dec_cursor();
        }

        tempc = LA;
      } else {
        if (F_is_TyB_TyC_TyD(SRC_EDT, AT_CURSOR)) {
          tempc = ALEF_;
          chg_l_toXor_X();
        } else {
          tempc = ALEF;
        }
      }

      if (!p_ri) {
        inc_cursor();
      }

      return tempc;

    case 'i':
      if (!curwin->w_cursor.col && STRLEN(get_cursor_line_ptr())) {
        if (!p_ri && !F_is_TyE(tempc)) {
          chg_c_to_X_orX_();
        }

        if (p_ri) {
          chg_c_to_X_or_X();
        }
      }

      if (!p_ri && !curwin->w_cursor.col) {
        return _HE;
      }

      if (!p_ri) {
        dec_cursor();
      }

      if (F_is_TyB_TyC_TyD(SRC_EDT, AT_CURSOR)) {
        tempc = _HE_;
      } else {
        tempc = _HE;
      }

      if (!p_ri) {
        inc_cursor();
      }
      break;

    case 'j':
      tempc = _TE;
      break;

    case 'J':
      if (!curwin->w_cursor.col && STRLEN(get_cursor_line_ptr())) {
        if (p_ri) {
          chg_c_to_X_or_X();
        }
      }

      if (!p_ri) {
        if (!curwin->w_cursor.col) {
          return TEE;
        }
        dec_cursor();
      }

      if (F_is_TyB_TyC_TyD(SRC_EDT, AT_CURSOR)) {
        tempc = TEE_;
        chg_l_toXor_X();
      } else {
        tempc = TEE;
      }

      if (!p_ri) {
        inc_cursor();
      }

      return tempc;

    case 'k' : tempc = _NOON ; break;
    case 'l' : tempc = _MIM  ; break;
    case 'm' : tempc = _PE   ; break;
    case 'n' :
    case 'N' : tempc = DAL   ; break;
    case 'o' : tempc = _XE   ; break;
    case 'p' : tempc = _HE_J ; break;
    case 'q' : tempc = _ZAD  ; break;
    case 'r' : tempc = _GHAF ; break;
    case 's' : tempc = _SIN  ; break;
    case 'S' : tempc = _IE   ; break;
    case 't' : tempc = _FE   ; break;

    case 'u':
      if (!curwin->w_cursor.col && STRLEN(get_cursor_line_ptr())) {
        if (!p_ri && !F_is_TyE(tempc)) {
          chg_c_to_X_orX_();
        }

        if (p_ri) {
          chg_c_to_X_or_X();
        }
      }

      if (!p_ri && !curwin->w_cursor.col) {
        return _AYN;
      }

      if (!p_ri) {
        dec_cursor();
      }

      if (F_is_TyB_TyC_TyD(SRC_EDT, AT_CURSOR)) {
        tempc = _AYN_;
      } else {
        tempc = _AYN;
      }

      if (!p_ri) {
        inc_cursor();
      }
      break;

    case 'v' :
    case 'V' : tempc = RE   ; break;
    case 'w' : tempc = _SAD ; break;
    case 'x' :
    case 'X' : tempc = _TA  ; break;

    case 'y':
      if (!curwin->w_cursor.col && STRLEN(get_cursor_line_ptr())) {
        if (!p_ri && !F_is_TyE(tempc)) {
          chg_c_to_X_orX_();
        }

        if (p_ri) {
          chg_c_to_X_or_X();
        }
      }

      if (!p_ri && !curwin->w_cursor.col) {
        return _GHAYN;
      }

      if (!p_ri) {
        dec_cursor();
      }

      if (F_is_TyB_TyC_TyD(SRC_EDT, AT_CURSOR)) {
        tempc = _GHAYN_;
      } else {
        tempc = _GHAYN;
      }

      if (!p_ri) {
        inc_cursor();
      }

      break;

    case 'z'  : tempc = _ZA    ; break;
    case 'Z'  : tempc = _KAF_H ; break;
    case ';'  : tempc = _KAF   ; break;
    case '\'' : tempc = _GAF   ; break;
    case ','  : tempc = WAW    ; break;
    case '['  : tempc = _JIM   ; break;
    case ']'  : tempc = _CHE   ; break;
  }

  if ((F_isalpha(tempc) || F_isdigit(tempc))) {
    if (!curwin->w_cursor.col && STRLEN(get_cursor_line_ptr())) {
      if (!p_ri && !F_is_TyE(tempc)) {
        chg_c_to_X_orX_();
      }

      if (p_ri) {
        chg_c_to_X_or_X();
      }
    }

    if (curwin->w_cursor.col) {
      if (!p_ri) {
        dec_cursor();
      }

      if (F_is_TyE(tempc)) {
        chg_l_toXor_X();
      } else {
        chg_l_to_X_orX_();
      }

      if (!p_ri) {
        inc_cursor();
      }
    }
  }

  if (tempc) {
    return tempc;
  }
  return c;
}
Пример #11
0
/// Convert the given Farsi character into a _X or _X_ type
///
/// @param c The character to convert.
///
/// @return Farsi character converted to a _X or _X_ type.
static int toF_Xor_X_(int c)
{
  int tempc;

  switch (c) {
    case BE:
      return _BE;

    case PE:
      return _PE;

    case TE:
      return _TE;

    case SE:
      return _SE;

    case JIM:
      return _JIM;

    case CHE:
      return _CHE;

    case HE_J:
      return _HE_J;

    case XE:
      return _XE;

    case SIN:
      return _SIN;

    case SHIN:
      return _SHIN;

    case SAD:
      return _SAD;

    case ZAD:
      return _ZAD;

    case AYN:
      return _AYN;

    case AYN_:
      return _AYN_;

    case GHAYN:
      return _GHAYN;

    case GHAYN_:
      return _GHAYN_;

    case FE:
      return _FE;

    case GHAF:
      return _GHAF;

    case KAF:
      return _KAF;

    case GAF:
      return _GAF;

    case LAM:
      return _LAM;

    case MIM:
      return _MIM;

    case NOON:
      return _NOON;

    case YE:
    case YE_:
      return _YE;

    case YEE:
    case YEE_:
      return _YEE;

    case IE:
    case IE_:
      return _IE;

    case F_HE:
      tempc = _HE;

      if (p_ri &&
          (curwin->w_cursor.col + 1 < (colnr_T)STRLEN(get_cursor_line_ptr()))) {
        inc_cursor();
        if (F_is_TyB_TyC_TyD(SRC_EDT, AT_CURSOR)) {
          tempc = _HE_;
        }
        dec_cursor();
      }

      if (!p_ri && STRLEN(get_cursor_line_ptr())) {
        dec_cursor();
        if (F_is_TyB_TyC_TyD(SRC_EDT, AT_CURSOR)) {
          tempc = _HE_;
        }
        inc_cursor();
      }

      return tempc;
  }
  return 0;
}