开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 编辑器/阅读器 > 查看源码
farsi.c
资源名称：vim53src.zip　[点击查看]
上传用户：gddssl
上传日期：2007-01-06
资源大小：1003k
文件大小：39k
源码类别：

编辑器/阅读器

开发平台：

DOS

farsi.c：源码内容
  1. /* vi:set ts=8 sts=4 sw=4:
  2.  *
  3.  * VIM - Vi IMproved by Bram Moolenaar
  4.  *
  5.  * Do ":help uganda"  in Vim to read copying and usage conditions.
  6.  * Do ":help credits" in Vim to see a list of people who contributed.
  7.  */
  9. /*
  10.  * farsi.c: functions for Farsi language
  11.  *
  12.  * Included by main.c, when FKMAP is defined.
  13.  */
  15. static int toF_Xor_X_ __ARGS((int c));
  16. static int F_is_TyE __ARGS((int c));
  17. static int F_is_TyC_TyD __ARGS((int c));
  18. static int F_is_TyB_TyC_TyD __ARGS((int src, int offset));
  19. static int toF_TyB __ARGS((int c));
  20. static void put_curr_and_l_to_X __ARGS((int c));
  21. static void put_and_redo __ARGS((int c));
  22. static void chg_c_toX_orX __ARGS((void));
  23. static void chg_c_to_X_orX_ __ARGS((void));
  24. static void chg_c_to_X_or_X __ARGS((void));
  25. static void chg_l_to_X_orX_ __ARGS((void));
  26. static void chg_l_toXor_X __ARGS((void));
  27. static void chg_r_to_Xor_X_ __ARGS((void));
  28. static int toF_leading __ARGS((int c));
  29. static int toF_Rjoin __ARGS((int c));
  30. static int canF_Ljoin __ARGS((int c));
  31. static int canF_Rjoin __ARGS((int c));
  32. static int F_isterm __ARGS((int c));
  33. static int toF_ending __ARGS((int c));
  34. static void lrswapbuf __ARGS((char_u *buf, int len));
  36. /*
  37. ** Convert the given Farsi character into a _X or _X_ type
  38. */
  39.     static int
  40. toF_Xor_X_(c)
  41.     int c;
  42. {
  43.     int tempc;
  45.     switch (c)
  46.     {
  47. case BE:
  48. return _BE;
  49. case PE:
  50. return _PE;
  51. case TE:
  52. return _TE;
  53. case SE:
  54. return _SE;
  55. case JIM:
  56. return _JIM;
  57. case CHE:
  58. return _CHE;
  59. case HE_J:
  60. return _HE_J;
  61. case XE:
  62. return _XE;
  63. case SIN:
  64. return _SIN;
  65. case SHIN:
  66. return _SHIN;
  67. case SAD:
  68. return _SAD;
  69. case ZAD:
  70. return _ZAD;
  71. case AYN:
  72. return _AYN;
  73. case AYN_:
  74. return _AYN_;
  75. case GHAYN:
  76. return _GHAYN;
  77. case GHAYN_:
  78. return _GHAYN_;
  79. case FE:
  80. return _FE;
  81. case GHAF:
  82. return _GHAF;
  83. case KAF:
  84. return _KAF;
  85. case GAF:
  86. return _GAF;
  87. case LAM:
  88. return _LAM;
  89. case MIM:
  90. return _MIM;
  91. case NOON:
  92. return _NOON;
  93. case YE:
  94. case YE_:
  95. return _YE;
  96. case YEE:
  97. case YEE_:
  98. return _YEE;
  99. case IE:
  100. case IE_:
  101. return _IE;
  102. case F_HE:
  103. tempc = _HE;
  105. if (p_ri && (curwin->w_cursor.col+1 < STRLEN(ml_get_curline())))
  106. {
  107.     inc_cursor();
  109.     if (F_is_TyB_TyC_TyD(SRC_EDT, AT_CURSOR))
  110. tempc = _HE_;
  112.     dec_cursor();
  113. }
  114. if (!p_ri && STRLEN(ml_get_curline()))
  115. {
  116.     dec_cursor();
  118.     if (F_is_TyB_TyC_TyD(SRC_EDT, AT_CURSOR))
  119. tempc = _HE_;
  121.     inc_cursor();
  122. }
  124. return tempc;
  125.     }
  126.     return 0;
  127. }
  129. /*
  130. ** Convert the given Farsi character into Farsi capital character .
  131. */
  132.     int
  133. toF_TyA(c)
  134.     int c ;
  135. {
  136.     switch (c)
  137.     {
  138. case ALEF_:
  139. return ALEF;
  140. case ALEF_U_H_:
  141. return ALEF_U_H;
  142. case _BE:
  143. return BE;
  144. case _PE:
  145. return PE;
  146. case _TE:
  147. return TE;
  148. case _SE:
  149. return SE;
  150. case _JIM:
  151. return JIM;
  152. case _CHE:
  153. return CHE;
  154. case _HE_J:
  155. return HE_J;
  156. case _XE:
  157. return XE;
  158. case _SIN:
  159. return SIN;
  160. case _SHIN:
  161. return SHIN;
  162. case _SAD:
  163. return SAD;
  164. case _ZAD:
  165. return ZAD;
  166. case _AYN:
  167. case AYN_:
  168. case _AYN_:
  169. return AYN;
  170. case _GHAYN:
  171. case GHAYN_:
  172. case _GHAYN_:
  173. return GHAYN;
  174. case _FE:
  175. return FE;
  176. case _GHAF:
  177. return GHAF;
  178. /* I am not sure what it is !!!     case _KAF_H: */
  179. case _KAF:
  180. return KAF;
  181. case _GAF:
  182. return GAF;
  183. case _LAM:
  184. return LAM;
  185. case _MIM:
  186. return MIM;
  187. case _NOON:
  188. return NOON;
  189. case _YE:
  190. case YE_:
  191. return YE;
  192. case _YEE:
  193. case YEE_:
  194. return YEE;
  195. case TEE_:
  196. return TEE;
  197. case _IE:
  198. case IE_:
  199. return IE;
  200. case _HE:
  201. case _HE_:
  202. return F_HE;
  203.     }
  204.     return c;
  205. }
  207. /*
  208. ** Is the character under the cursor+offset in the given buffer a join type.
  209. ** That is a character that is combined with the others.
  210. ** Note: the offset is used only for command line buffer.
  211. */
  212.     static int
  213. F_is_TyB_TyC_TyD(src, offset)
  214.     int     src,    offset;
  215. {
  216. int c;
  218.     if ( src == SRC_EDT)
  219. c = gchar_cursor();
  220.     else
  221. c = cmd_gchar(AT_CURSOR+offset);
  223.     switch (c)
  224.     {
  225. case _LAM:
  226. case _BE:
  227. case _PE:
  228. case _TE:
  229. case _SE:
  230. case _JIM:
  231. case _CHE:
  232. case _HE_J:
  233. case _XE:
  234. case _SIN:
  235. case _SHIN:
  236. case _SAD:
  237. case _ZAD:
  238. case _TA:
  239. case _ZA:
  240. case _AYN:
  241. case _AYN_:
  242. case _GHAYN:
  243. case _GHAYN_:
  244. case _FE:
  245. case _GHAF:
  246. case _KAF:
  247. case _KAF_H:
  248. case _GAF:
  249. case _MIM:
  250. case _NOON:
  251. case _YE:
  252. case _YEE:
  253. case _IE:
  254. case _HE_:
  255. case _HE:
  256. return TRUE;
  257.     }
  258.     return FALSE;
  259. }
  261. /*
  262. ** Is the Farsi character one of the terminating only type.
  263. */
  264.     static int
  265. F_is_TyE(c)
  266.     int     c;
  267. {
  268.     switch (c)
  269.     {
  270. case ALEF_A:
  271. case ALEF_D_H:
  272. case DAL:
  273. case ZAL:
  274. case RE:
  275. case ZE:
  276. case JE:
  277. case WAW:
  278. case WAW_H:
  279. case HAMZE:
  280. return TRUE;
  281.     }
  282.     return FALSE;
  283. }
  285. /*
  286. ** Is the Farsi character one of the none leading type.
  287. */
  288.     static int
  289. F_is_TyC_TyD(c)
  290.     int     c;
  291. {
  292.     switch (c)
  293.     {
  294. case ALEF_:
  295. case ALEF_U_H_:
  296. case _AYN_:
  297. case AYN_:
  298. case _GHAYN_:
  299. case GHAYN_:
  300. case _HE_:
  301. case YE_:
  302. case IE_:
  303. case TEE_:
  304. case YEE_:
  305. return TRUE;
  306.     }
  307.     return FALSE;
  308. }
  310. /*
  311. ** Convert a none leading Farsi char into a leading type.
  312. */
  313.     static int
  314. toF_TyB(c)
  315.     int     c;
  316. {
  317.     switch (c)
  318.     {
  319. case ALEF_: return ALEF;
  320. case ALEF_U_H_:     return ALEF_U_H;
  321. case _AYN_: return _AYN;
  322. case AYN_: return AYN; /* exception - there are many of them */
  323. case _GHAYN_: return _GHAYN;
  324. case GHAYN_: return GHAYN; /* exception - there are many of them */
  325. case _HE_: return _HE;
  326. case YE_: return YE;
  327. case IE_: return IE;
  328. case TEE_: return TEE;
  329. case YEE_: return YEE;
  330.     }
  331.     return c;
  332. }
  334. /*
  335. ** Overwrite the current redo and cursor characters + left adjust
  336. */
  337.     static void
  338. put_curr_and_l_to_X(c)
  339.     int   c;
  340. {
  341.     int tempc;
  343.     if (curwin->w_p_rl && p_ri)
  344. return;
  346.     if ( (curwin->w_cursor.col < STRLEN(ml_get_curline())))
  347.     {
  348. if ((p_ri && curwin->w_cursor.col) || !p_ri)
  349. {
  350.     if (p_ri)
  351. dec_cursor();
  352.     else
  353. inc_cursor();
  355.     if (F_is_TyC_TyD((tempc = gchar_cursor())))
  356.     {
  357. pchar_cursor(toF_TyB(tempc));
  358. AppendCharToRedobuff(K_BS);
  359. AppendCharToRedobuff(tempc);
  360.     }
  362.     if (p_ri)
  363. inc_cursor();
  364.     else
  365. dec_cursor();
  366. }
  367.     }
  369.     put_and_redo(c);
  370. }
  372.     static void
  373. put_and_redo(c)
  374.     int c;
  375. {
  376.     pchar_cursor(c);
  377.     AppendCharToRedobuff(K_BS);
  378.     AppendCharToRedobuff(c);
  379. }
  381. /*
  382. ** Change the char. under the cursor to a X_ or X type
  383. */
  384.     static void
  385. chg_c_toX_orX()
  386. {
  387.     int tempc, curc;
  389.     switch ((curc = gchar_cursor()))
  390.     {
  391. case _BE:
  392. tempc = BE;
  393. break;
  394. case _PE:
  395. tempc = PE;
  396. break;
  397. case _TE:
  398. tempc = TE;
  399. break;
  400. case _SE:
  401. tempc = SE;
  402. break;
  403. case _JIM:
  404. tempc = JIM;
  405. break;
  406. case _CHE:
  407. tempc = CHE;
  408. break;
  409. case _HE_J:
  410. tempc = HE_J;
  411. break;
  412. case _XE:
  413. tempc = XE;
  414. break;
  415. case _SIN:
  416. tempc = SIN;
  417. break;
  418. case _SHIN:
  419. tempc = SHIN;
  420. break;
  421. case _SAD:
  422. tempc = SAD;
  423. break;
  424. case _ZAD:
  425. tempc = ZAD;
  426. break;
  427. case _FE:
  428. tempc = FE;
  429. break;
  430. case _GHAF:
  431. tempc = GHAF;
  432. break;
  433. case _KAF_H:
  434. case _KAF:
  435. tempc = KAF;
  436. break;
  437. case _GAF:
  438. tempc = GAF;
  439. break;
  440. case _AYN:
  441. tempc = AYN;
  442. break;
  443. case _AYN_:
  444. tempc = AYN_;
  445. break;
  446. case _GHAYN:
  447. tempc = GHAYN;
  448. break;
  449. case _GHAYN_:
  450. tempc = GHAYN_;
  451. break;
  452. case _LAM:
  453. tempc = LAM;
  454. break;
  455. case _MIM:
  456. tempc = MIM;
  457. break;
  458. case _NOON:
  459. tempc = NOON;
  460. break;
  461. case _HE:
  462. case _HE_:
  463. tempc = F_HE;
  464. break;
  465. case _YE:
  466. case _IE:
  467. case _YEE:
  468. if (p_ri)
  469. {
  470.     inc_cursor();
  471.     if (F_is_TyB_TyC_TyD(SRC_EDT, AT_CURSOR))
  472.     tempc = (curc == _YE ? YE_ :
  473.     (curc == _IE ? IE_ : YEE_));
  474.     else
  475.     tempc = (curc == _YE ? YE :
  476.     (curc == _IE ? IE : YEE));
  477.     dec_cursor();
  478. }
  479. else
  480. {
  481.     if (curwin->w_cursor.col)
  482.     {
  483. dec_cursor();
  484. if (F_is_TyB_TyC_TyD(SRC_EDT, AT_CURSOR))
  485. tempc = (curc == _YE ? YE_ :
  486. (curc == _IE ? IE_ : YEE_));
  487. else
  488. tempc = (curc == _YE ? YE :
  489. (curc == _IE ? IE : YEE));
  490. inc_cursor();
  491.     }
  492.     else
  493.     tempc = (curc == _YE ? YE :
  494.     (curc == _IE ? IE : YEE));
  495. }
  496. break;
  497. default:
  498. tempc = 0;
  499.     }
  501.     if (tempc)
  502. put_and_redo(tempc);
  503. }
  505. /*
  506. ** Change the char. under the cursor to a _X_ or X_ type
  507. */
  509.     static void
  510. chg_c_to_X_orX_()
  511. {
  512.     int tempc;
  514.     switch (gchar_cursor())
  515.     {
  516. case ALEF:
  517. tempc = ALEF_;
  518. break;
  519. case ALEF_U_H:
  520. tempc = ALEF_U_H_;
  521. break;
  522. case _AYN:
  523. tempc = _AYN_;
  524. break;
  525. case AYN:
  526. tempc = AYN_;
  527. break;
  528. case _GHAYN:
  529. tempc = _GHAYN_;
  530. break;
  531. case GHAYN:
  532. tempc = GHAYN_;
  533. break;
  534. case _HE:
  535. tempc = _HE_;
  536. break;
  537. case YE:
  538. tempc = YE_;
  539. break;
  540. case IE:
  541. tempc = IE_;
  542. break;
  543. case TEE:
  544. tempc = TEE_;
  545. break;
  546. case YEE:
  547. tempc = YEE_;
  548. break;
  549. default:
  550. tempc = 0;
  551.     }
  553.     if (tempc)
  554. put_and_redo(tempc);
  555. }
  557. /*
  558. ** Change the char. under the cursor to a _X_ or _X type
  559. */
  560.     static void
  561. chg_c_to_X_or_X ()
  562. {
  563.     int tempc;
  565.     tempc = gchar_cursor();
  567.     if (curwin->w_cursor.col+1 < STRLEN(ml_get_curline()))
  568.     {
  569. inc_cursor();
  571. if ((tempc == F_HE) && (F_is_TyB_TyC_TyD(SRC_EDT, AT_CURSOR)))
  572. {
  573.     tempc = _HE_;
  575.     dec_cursor();
  577.     put_and_redo(tempc);
  578.     return;
  579. }
  581. dec_cursor();
  582.     }
  584.     if ((tempc = toF_Xor_X_(tempc)))
  585. put_and_redo(tempc);
  586. }
  588. /*
  589. ** Change the character left to the cursor to a _X_ or X_ type
  590. */
  591.     static void
  592. chg_l_to_X_orX_ ()
  593. {
  594.     int tempc;
  596.     if (!curwin->w_cursor.col &&
  597. (curwin->w_cursor.col+1 == STRLEN(ml_get_curline())))
  598. return;
  600.     if (!curwin->w_cursor.col && p_ri)
  601. return;
  603.     if (p_ri)
  604. dec_cursor();
  605.     else
  606. inc_cursor();
  608.     switch (gchar_cursor())
  609.     {
  610. case ALEF:
  611. tempc = ALEF_;
  612. break;
  613. case ALEF_U_H:
  614. tempc = ALEF_U_H_;
  615. break;
  616. case _AYN:
  617. tempc = _AYN_;
  618. break;
  619. case AYN:
  620. tempc = AYN_;
  621. break;
  622. case _GHAYN:
  623. tempc = _GHAYN_;
  624. break;
  625. case GHAYN:
  626. tempc = GHAYN_;
  627. break;
  628. case _HE:
  629. tempc = _HE_;
  630. break;
  631. case YE:
  632. tempc = YE_;
  633. break;
  634. case IE:
  635. tempc = IE_;
  636. break;
  637. case TEE:
  638. tempc = TEE_;
  639. break;
  640. case YEE:
  641. tempc = YEE_;
  642. break;
  643. default:
  644. tempc = 0;
  645.     }
  647.     if (tempc)
  648. put_and_redo(tempc);
  650.     if (p_ri)
  651. inc_cursor();
  652.     else
  653. dec_cursor();
  654. }
  656. /*
  657. ** Change the charcter left to the cursor to a X or _X type
  658. */
  660.     static void
  661. chg_l_toXor_X ()
  662. {
  663.     int tempc;
  665.     if (!curwin->w_cursor.col &&
  666. (curwin->w_cursor.col+1 == STRLEN(ml_get_curline())))
  667. return;
  669.     if (!curwin->w_cursor.col && p_ri)
  670. return;
  672.     if (p_ri)
  673. dec_cursor();
  674.     else
  675. inc_cursor();
  677.     switch (gchar_cursor())
  678.     {
  679. case ALEF_:
  680. tempc = ALEF;
  681. break;
  682. case ALEF_U_H_:
  683. tempc = ALEF_U_H;
  684. break;
  685. case _AYN_:
  686. tempc = _AYN;
  687. break;
  688. case AYN_:
  689. tempc = AYN;
  690. break;
  691. case _GHAYN_:
  692. tempc = _GHAYN;
  693. break;
  694. case GHAYN_:
  695. tempc = GHAYN;
  696. break;
  697. case _HE_:
  698. tempc = _HE;
  699. break;
  700. case YE_:
  701. tempc = YE;
  702. break;
  703. case IE_:
  704. tempc = IE;
  705. break;
  706. case TEE_:
  707. tempc = TEE;
  708. break;
  709. case YEE_:
  710. tempc = YEE;
  711. break;
  712. default:
  713. tempc = 0;
  714.     }
  716.     if (tempc)
  717. put_and_redo(tempc);
  719.     if (p_ri)
  720. inc_cursor();
  721.     else
  722. dec_cursor();
  723. }
  725. /*
  726. ** Change the charcter right to the cursor to a _X or _X_ type
  727. */
  729.     static void
  730. chg_r_to_Xor_X_()
  731. {
  732. int tempc, c;
  734.     if (curwin->w_cursor.col)
  735.     {
  736. if (!p_ri)
  737.     dec_cursor();
  739. tempc = gchar_cursor();
  741. if ((c = toF_Xor_X_(tempc)))
  742.     put_and_redo(c);
  744. if (!p_ri)
  745.     inc_cursor();
  747.     }
  748. }
  750. /*
  751. ** Map Farsi keyboard when in fkmap mode.
  752. */
  754.     int
  755. fkmap(c)
  756.     int c;
  757. {
  758.     int tempc;
  759.     static int revins;
  761.     if (vim_isdigit(c) || ((c == '.' || c == '+' || c == '-' ||
  762. c == '^' || c == '%' || c == '#' || c == '=')  && revins))
  763.     {
  764. if (!revins)
  765. {
  766.     if (curwin->w_cursor.col)
  767.     {
  768. if (!p_ri)
  769.     dec_cursor();
  771.     chg_c_toX_orX ();
  772.     chg_l_toXor_X ();
  774. if (!p_ri)
  775.     inc_cursor();
  776.     }
  777. }
  779. arrow_used = TRUE;
  780. stop_arrow();
  782. if (!curwin->w_p_rl && revins)
  783.     inc_cursor();
  785. ++revins;
  786. p_ri=1;
  787.     }
  788.     else
  789.     {
  790. if (revins)
  791. {
  792.     arrow_used = TRUE;
  793.     stop_arrow();
  795.     revins=0;
  796.     tempc = gchar_cursor();
  797.     if (curwin->w_p_rl)
  798.     {
  799. while ((F_isdigit(gchar_cursor())
  800.     || (gchar_cursor() == F_PERIOD
  801. || gchar_cursor() == F_PLUS
  802. || gchar_cursor() == F_MINUS
  803. || gchar_cursor() == F_MUL
  804. || gchar_cursor() == F_DIVIDE
  805. || gchar_cursor() == F_PERCENT
  806. || gchar_cursor() == F_EQUALS))
  807. && gchar_cursor()!= NUL)
  808.     ++curwin->w_cursor.col;
  809.     }
  810.     else
  811.     {
  812. if (curwin->w_cursor.col)
  813.     while ((F_isdigit(gchar_cursor())
  814.     || (gchar_cursor() == F_PERIOD
  815. || gchar_cursor() == F_PLUS
  816. || gchar_cursor() == F_MINUS
  817. || gchar_cursor() == F_MUL
  818. || gchar_cursor() == F_DIVIDE
  819. || gchar_cursor() == F_PERCENT
  820. || gchar_cursor() == F_EQUALS))
  821.     && --curwin->w_cursor.col);
  823. if (!F_isdigit(gchar_cursor()))
  824.     ++curwin->w_cursor.col;
  825.     }
  826. }
  827.     }
  829.     if (!revins)
  830.     {
  831. if (curwin->w_p_rl)
  832.     p_ri=0;
  833. if (!curwin->w_p_rl)
  834.     p_ri=1;
  835.     }
  837.     if ((c < 0x100) && (isalpha(c) || c == '&' ||   c == '^' || c == ';' ||
  838.     c == '''|| c == ',' || c == '[' ||
  839.     c == ']' || c == '{' || c == '}' ))
  840. chg_r_to_Xor_X_();
  842.     tempc = 0;
  844.     switch (c)
  845.     {
  846. case '`':
  847. case ' ':
  848. case '.':
  849. case '!':
  850. case '"':
  851. case '$':
  852. case '%':
  853. case '^':
  854. case '&':
  855. case '/':
  856. case '(':
  857. case ')':
  858. case '=':
  859. case '\':
  860. case '?':
  861. case '+':
  862. case '-':
  863. case '_':
  864. case '*':
  865. case ':':
  866. case '#':
  867. case '~':
  868. case '@':
  869. case '<':
  870. case '>':
  871. case '{':
  872. case '}':
  873. case '|':
  874. case '0':
  875. case '1':
  876. case '2':
  877. case '3':
  878. case '4':
  879. case '5':
  880. case '6':
  881. case '7':
  882. case '8':
  883. case '9':
  884. case 'B':
  885. case 'E':
  886. case 'F':
  887. case 'H':
  888. case 'I':
  889. case 'K':
  890. case 'L':
  891. case 'M':
  892. case 'O':
  893. case 'P':
  894. case 'Q':
  895. case 'R':
  896. case 'T':
  897. case 'U':
  898. case 'W':
  899. case 'Y':
  900. case  NL:
  901. case  TAB:
  903.     if (p_ri && c == NL && curwin->w_cursor.col)
  904.     {
  905. /*
  906. ** If the char before the cursor is _X_ or X_ do not change
  907. ** the one under the cursor with X type.
  908. */
  910. dec_cursor();
  912. if (F_isalpha(gchar_cursor()))
  913. {
  914.     inc_cursor();
  915.     return NL;
  916. }
  918. inc_cursor();
  919.     }
  921.     if (!p_ri)
  922.     if (!curwin->w_cursor.col)
  923.     {
  924. switch (c)
  925. {
  926.     case '0': return FARSI_0;
  927.     case '1': return FARSI_1;
  928.     case '2': return FARSI_2;
  929.     case '3': return FARSI_3;
  930.     case '4': return FARSI_4;
  931.     case '5': return FARSI_5;
  932.     case '6': return FARSI_6;
  933.     case '7': return FARSI_7;
  934.     case '8': return FARSI_8;
  935.     case '9': return FARSI_9;
  936.     case 'B': return F_PSP;
  937.     case 'E': return JAZR_N;
  938.     case 'F': return ALEF_D_H;
  939.     case 'H': return ALEF_A;
  940.     case 'I': return TASH;
  941.     case 'K': return F_LQUOT;
  942.     case 'L': return F_RQUOT;
  943.     case 'M': return HAMZE;
  944.     case 'O': return '[';
  945.     case 'P': return ']';
  946.     case 'Q': return OO;
  947.     case 'R': return MAD_N;
  948.     case 'T': return OW;
  949.     case 'U': return MAD;
  950.     case 'W': return OW_OW;
  951.     case 'Y': return JAZR;
  952.     case '`': return F_PCN;
  953.     case '!': return F_EXCL;
  954.     case '@': return F_COMMA;
  955.     case '#': return F_DIVIDE;
  956.     case '$': return F_CURRENCY;
  957.     case '%': return F_PERCENT;
  958.     case '^': return F_MUL;
  959.     case '&': return F_BCOMMA;
  960.     case '*': return F_STAR;
  961.     case '(': return F_LPARENT;
  962.     case ')': return F_RPARENT;
  963.     case '-': return F_MINUS;
  964.     case '_': return F_UNDERLINE;
  965.     case '=': return F_EQUALS;
  966.     case '+': return F_PLUS;
  967.     case '\': return F_BSLASH;
  968.     case '|': return F_PIPE;
  969.     case ':': return F_DCOLON;
  970.     case '"': return F_SEMICOLON;
  971.     case '.': return F_PERIOD;
  972.     case '/': return F_SLASH;
  973.     case '<': return F_LESS;
  974.     case '>': return F_GREATER;
  975.     case '?': return F_QUESTION;
  976.     case ' ': return F_BLANK;
  977. }
  978. break;
  979.     }
  980.     if (!p_ri)
  981. dec_cursor();
  983.     switch ((tempc = gchar_cursor()))
  984.     {
  985. case _BE:
  986. case _PE:
  987. case _TE:
  988. case _SE:
  989. case _JIM:
  990. case _CHE:
  991. case _HE_J:
  992. case _XE:
  993. case _SIN:
  994. case _SHIN:
  995. case _SAD:
  996. case _ZAD:
  997. case _FE:
  998. case _GHAF:
  999. case _KAF:
  1000. case _KAF_H:
  1001. case _GAF:
  1002. case _LAM:
  1003. case _MIM:
  1004. case _NOON:
  1005. case _HE:
  1006. case _HE_:
  1007. case _TA:
  1008. case _ZA:
  1009. put_curr_and_l_to_X(toF_TyA(tempc));
  1010. break;
  1011. case _AYN:
  1012. case _AYN_:
  1014. if (!p_ri)
  1015.     if (!curwin->w_cursor.col)
  1016.     {
  1017. put_curr_and_l_to_X(AYN);
  1018. break;
  1019.     }
  1021. if (p_ri)
  1022.     inc_cursor();
  1023. else
  1024.     dec_cursor();
  1026. if (F_is_TyB_TyC_TyD(SRC_EDT, AT_CURSOR))
  1027.     tempc = AYN_;
  1028. else
  1029.     tempc = AYN;
  1031. if (p_ri)
  1032.     dec_cursor();
  1033. else
  1034.     inc_cursor();
  1036. put_curr_and_l_to_X(tempc);
  1038. break;
  1039. case _GHAYN:
  1040. case _GHAYN_:
  1042. if (!p_ri)
  1043.     if (!curwin->w_cursor.col)
  1044.     {
  1045. put_curr_and_l_to_X(GHAYN);
  1046. break;
  1047.     }
  1049. if (p_ri)
  1050.     inc_cursor();
  1051. else
  1052.     dec_cursor();
  1054. if (F_is_TyB_TyC_TyD(SRC_EDT, AT_CURSOR))
  1055.     tempc = GHAYN_;
  1056. else
  1057.     tempc = GHAYN;
  1059. if (p_ri)
  1060.     dec_cursor();
  1061. else
  1062.     inc_cursor();
  1064. put_curr_and_l_to_X(tempc);
  1065. break;
  1066. case _YE:
  1067. case _IE:
  1068. case _YEE:
  1069. if (!p_ri)
  1070.     if (!curwin->w_cursor.col)
  1071.     {
  1072. put_curr_and_l_to_X((tempc == _YE ? YE :
  1073.     (tempc == _IE ? IE : YEE)));
  1074. break;
  1075.     }
  1077. if (p_ri)
  1078.     inc_cursor();
  1079. else
  1080.     dec_cursor();
  1082. if (F_is_TyB_TyC_TyD(SRC_EDT, AT_CURSOR))
  1083. tempc = (tempc == _YE ? YE_ :
  1084.     (tempc == _IE ? IE_ : YEE_));
  1085. else
  1086. tempc = (tempc == _YE ? YE :
  1087.     (tempc == _IE ? IE : YEE));
  1089. if (p_ri)
  1090.     dec_cursor();
  1091. else
  1092.     inc_cursor();
  1094. put_curr_and_l_to_X(tempc);
  1095. break;
  1096. }
  1098. if (!p_ri)
  1099.     inc_cursor();
  1101. tempc = 0;
  1103. switch (c)
  1104. {
  1105.     case '0': return FARSI_0;
  1106.     case '1': return FARSI_1;
  1107.     case '2': return FARSI_2;
  1108.     case '3': return FARSI_3;
  1109.     case '4': return FARSI_4;
  1110.     case '5': return FARSI_5;
  1111.     case '6': return FARSI_6;
  1112.     case '7': return FARSI_7;
  1113.     case '8': return FARSI_8;
  1114.     case '9': return FARSI_9;
  1115.     case 'B': return F_PSP;
  1116.     case 'E': return JAZR_N;
  1117.     case 'F': return ALEF_D_H;
  1118.     case 'H': return ALEF_A;
  1119.     case 'I': return TASH;
  1120.     case 'K': return F_LQUOT;
  1121.     case 'L': return F_RQUOT;
  1122.     case 'M': return HAMZE;
  1123.     case 'O': return '[';
  1124.     case 'P': return ']';
  1125.     case 'Q': return OO;
  1126.     case 'R': return MAD_N;
  1127.     case 'T': return OW;
  1128.     case 'U': return MAD;
  1129.     case 'W': return OW_OW;
  1130.     case 'Y': return JAZR;
  1131.     case '`': return F_PCN;
  1132.     case '!': return F_EXCL;
  1133.     case '@': return F_COMMA;
  1134.     case '#': return F_DIVIDE;
  1135.     case '$': return F_CURRENCY;
  1136.     case '%': return F_PERCENT;
  1137.     case '^': return F_MUL;
  1138.     case '&': return F_BCOMMA;
  1139.     case '*': return F_STAR;
  1140.     case '(': return F_LPARENT;
  1141.     case ')': return F_RPARENT;
  1142.     case '-': return F_MINUS;
  1143.     case '_': return F_UNDERLINE;
  1144.     case '=': return F_EQUALS;
  1145.     case '+': return F_PLUS;
  1146.     case '\': return F_BSLASH;
  1147.     case '|': return F_PIPE;
  1148.     case ':': return F_DCOLON;
  1149.     case '"': return F_SEMICOLON;
  1150.     case '.': return F_PERIOD;
  1151.     case '/': return F_SLASH;
  1152.     case '<': return F_LESS;
  1153.     case '>': return F_GREATER;
  1154.     case '?': return F_QUESTION;
  1155.     case ' ': return F_BLANK;
  1156. }
  1157. break;
  1159. case 'a':
  1160. tempc = _SHIN;
  1161.     break;
  1162. case 'A':
  1163. tempc = WAW_H;
  1164.     break;
  1165. case 'b':
  1166. tempc = ZAL;
  1167.     break;
  1168. case 'c':
  1169. tempc = ZE;
  1170.     break;
  1171. case 'C':
  1172. tempc = JE;
  1173.     break;
  1174. case 'd':
  1175. tempc = _YE;
  1176.     break;
  1177. case 'D':
  1178. tempc = _YEE;
  1179.     break;
  1180. case 'e':
  1181. tempc = _SE;
  1182.     break;
  1183. case 'f':
  1184. tempc = _BE;
  1185.     break;
  1186. case 'g':
  1187. tempc = _LAM;
  1188.     break;
  1189. case 'G':
  1190.     if (!curwin->w_cursor.col  &&  STRLEN(ml_get_curline()))
  1191. {
  1193. if (gchar_cursor() == _LAM)
  1194.     chg_c_toX_orX ();
  1195. else
  1196.     if (p_ri)
  1197. chg_c_to_X_or_X ();
  1198.     }
  1200.     if (!p_ri)
  1201. if (!curwin->w_cursor.col)
  1202.     return ALEF_U_H;
  1204.     if (!p_ri)
  1205. dec_cursor();
  1207.     if (gchar_cursor() == _LAM)
  1208.     {
  1209. chg_c_toX_orX ();
  1210. chg_l_toXor_X ();
  1211.     tempc = ALEF_U_H;
  1212.     }
  1213.     else
  1214. if (F_is_TyB_TyC_TyD(SRC_EDT, AT_CURSOR))
  1215. {
  1216. tempc = ALEF_U_H_;
  1217.     chg_l_toXor_X ();
  1218. }
  1219. else
  1220. tempc = ALEF_U_H;
  1222.     if (!p_ri)
  1223. inc_cursor();
  1225.     return tempc;
  1226. case 'h':
  1227.     if (!curwin->w_cursor.col  &&  STRLEN(ml_get_curline()))
  1228. {
  1229. if (p_ri)
  1230.     chg_c_to_X_or_X ();
  1232.     }
  1234.     if (!p_ri)
  1235. if (!curwin->w_cursor.col)
  1236.     return ALEF;
  1238.     if (!p_ri)
  1239. dec_cursor();
  1241.     if (gchar_cursor() == _LAM)
  1242.     {
  1243. chg_l_toXor_X();
  1244. del_char(FALSE);
  1245. AppendCharToRedobuff(K_BS);
  1247. if (!p_ri)
  1248.     dec_cursor();
  1250.     tempc = LA;
  1251.     }
  1252.     else
  1253.     {
  1254. if (F_is_TyB_TyC_TyD(SRC_EDT, AT_CURSOR))
  1255. {
  1256. tempc = ALEF_;
  1257.     chg_l_toXor_X ();
  1258. }
  1259. else
  1260. tempc = ALEF;
  1261.     }
  1263.     if (!p_ri)
  1264. inc_cursor();
  1266.     return tempc;
  1267. case 'i':
  1268.     if (!curwin->w_cursor.col  &&  STRLEN(ml_get_curline()))
  1269. {
  1270. if (!p_ri && !F_is_TyE(tempc))
  1271.     chg_c_to_X_orX_ ();
  1272. if (p_ri)
  1273.     chg_c_to_X_or_X ();
  1275.     }
  1277.     if (!p_ri && !curwin->w_cursor.col)
  1278. return _HE;
  1280.     if (!p_ri)
  1281. dec_cursor();
  1283.     if (F_is_TyB_TyC_TyD(SRC_EDT, AT_CURSOR))
  1284.     tempc = _HE_;
  1285.     else
  1286.     tempc = _HE;
  1288.     if (!p_ri)
  1289. inc_cursor();
  1290.     break;
  1291. case 'j':
  1292. tempc = _TE;
  1293.     break;
  1294. case 'J':
  1295.     if (!curwin->w_cursor.col  &&  STRLEN(ml_get_curline()))
  1296. {
  1297. if (p_ri)
  1298.     chg_c_to_X_or_X ();
  1300.     }
  1302.     if (!p_ri)
  1303. if (!curwin->w_cursor.col)
  1304.     return TEE;
  1306.     if (!p_ri)
  1307. dec_cursor();
  1309.     if (F_is_TyB_TyC_TyD(SRC_EDT, AT_CURSOR))
  1310.     {
  1311.     tempc = TEE_;
  1312. chg_l_toXor_X ();
  1313.     }
  1314.     else
  1315. tempc = TEE;
  1317.     if (!p_ri)
  1318. inc_cursor();
  1320.     return tempc;
  1321. case 'k':
  1322. tempc = _NOON;
  1323.     break;
  1324. case 'l':
  1325. tempc = _MIM;
  1326.     break;
  1327. case 'm':
  1328. tempc = _PE;
  1329.     break;
  1330. case 'n':
  1331. case 'N':
  1332. tempc = DAL;
  1333.     break;
  1334. case 'o':
  1335. tempc = _XE;
  1336.     break;
  1337. case 'p':
  1338. tempc = _HE_J;
  1339.     break;
  1340. case 'q':
  1341. tempc = _ZAD;
  1342.     break;
  1343. case 'r':
  1344. tempc = _GHAF;
  1345.     break;
  1346. case 's':
  1347. tempc = _SIN;
  1348.     break;
  1349. case 'S':
  1350. tempc = _IE;
  1351.     break;
  1352. case 't':
  1353. tempc = _FE;
  1354.     break;
  1355. case 'u':
  1356. if (!curwin->w_cursor.col  &&  STRLEN(ml_get_curline()))
  1357. {
  1358.     if (!p_ri && !F_is_TyE(tempc))
  1359. chg_c_to_X_orX_ ();
  1360.     if (p_ri)
  1361. chg_c_to_X_or_X ();
  1363. }
  1365. if (!p_ri && !curwin->w_cursor.col)
  1366.     return _AYN;
  1368. if (!p_ri)
  1369.     dec_cursor();
  1371. if (F_is_TyB_TyC_TyD(SRC_EDT, AT_CURSOR))
  1372.     tempc = _AYN_;
  1373. else
  1374.     tempc = _AYN;
  1376. if (!p_ri)
  1377.     inc_cursor();
  1378.     break;
  1379. case 'v':
  1380. case 'V':
  1381. tempc = RE;
  1382.     break;
  1383. case 'w':
  1384. tempc = _SAD;
  1385.     break;
  1386. case 'x':
  1387. case 'X':
  1388. tempc = _TA;
  1389.     break;
  1390. case 'y':
  1391.     if (!curwin->w_cursor.col  &&  STRLEN(ml_get_curline()))
  1392. {
  1393. if (!p_ri && !F_is_TyE(tempc))
  1394.     chg_c_to_X_orX_ ();
  1395. if (p_ri)
  1396.     chg_c_to_X_or_X ();
  1398.     }
  1400.     if (!p_ri && !curwin->w_cursor.col)
  1401. return _GHAYN;
  1403.     if (!p_ri)
  1404. dec_cursor();
  1406.     if (F_is_TyB_TyC_TyD(SRC_EDT, AT_CURSOR))
  1407. tempc = _GHAYN_;
  1408.     else
  1409. tempc = _GHAYN;
  1411.     if (!p_ri)
  1412. inc_cursor();
  1414.     break;
  1415. case 'z':
  1416. tempc = _ZA;
  1417.     break;
  1418. case 'Z':
  1419. tempc = _KAF_H;
  1420.     break;
  1421. case ';':
  1422. tempc = _KAF;
  1423.     break;
  1424. case ''':
  1425. tempc = _GAF;
  1426.     break;
  1427. case ',':
  1428. tempc = WAW;
  1429.     break;
  1430. case '[':
  1431. tempc = _JIM;
  1432.     break;
  1433. case ']':
  1434. tempc = _CHE;
  1435.     break;
  1436.     }
  1438.     if ((F_isalpha(tempc) || F_isdigit(tempc)))
  1439.     {
  1440. if (!curwin->w_cursor.col  &&  STRLEN(ml_get_curline()))
  1441.     {
  1442.     if (!p_ri && !F_is_TyE(tempc))
  1443. chg_c_to_X_orX_ ();
  1444.     if (p_ri)
  1445. chg_c_to_X_or_X ();
  1446. }
  1448. if (curwin->w_cursor.col)
  1449. {
  1450.     if (!p_ri)
  1451. dec_cursor();
  1453.     if (F_is_TyE(tempc))
  1454. chg_l_toXor_X ();
  1455.     else
  1456. chg_l_to_X_orX_ ();
  1458.     if (!p_ri)
  1459. inc_cursor();
  1460. }
  1461.     }
  1462.     if (tempc)
  1463. return tempc;
  1464.     return c;
  1465. }
  1467. /*
  1468. ** Convert a none leading Farsi char into a leading type.
  1469. */
  1470.     static int
  1471. toF_leading(c)
  1472.     int     c;
  1473. {
  1474.     switch (c)
  1475.     {
  1476. case ALEF_: return ALEF;
  1477. case ALEF_U_H_:     return ALEF_U_H;
  1478. case BE:    return _BE;
  1479. case PE:    return _PE;
  1480. case TE:    return _TE;
  1481. case SE:    return _SE;
  1482. case JIM:   return _JIM;
  1483. case CHE:   return _CHE;
  1484. case HE_J:  return _HE_J;
  1485. case XE:    return _XE;
  1486. case SIN:   return _SIN;
  1487. case SHIN:  return _SHIN;
  1488. case SAD:   return _SAD;
  1489. case ZAD:   return _ZAD;
  1491. case AYN:
  1492. case AYN_:
  1493. case _AYN_: return _AYN;
  1495. case GHAYN:
  1496. case GHAYN_:
  1497. case _GHAYN_: return _GHAYN;
  1499. case FE:    return _FE;
  1500. case GHAF:  return _GHAF;
  1501. case KAF:   return _KAF;
  1502. case GAF:   return _GAF;
  1503. case LAM:   return _LAM;
  1504. case MIM:   return _MIM;
  1505. case NOON:  return _NOON;
  1507. case _HE_:
  1508. case F_HE: return _HE;
  1510. case YE:
  1511. case YE_: return _YE;
  1513. case IE_:
  1514. case IE: return _IE;
  1516. case YEE:
  1517. case YEE_: return _YEE;
  1518.     }
  1519.     return c;
  1520. }
  1522. /*
  1523. ** Convert a given Farsi char into right joining type.
  1524. */
  1525.     static int
  1526. toF_Rjoin(c)
  1527.     int     c;
  1528. {
  1529.     switch (c)
  1530.     {
  1531. case ALEF:  return ALEF_;
  1532. case ALEF_U_H: return ALEF_U_H_;
  1533. case BE:    return _BE;
  1534. case PE:    return _PE;
  1535. case TE:    return _TE;
  1536. case SE:    return _SE;
  1537. case JIM:   return _JIM;
  1538. case CHE:   return _CHE;
  1539. case HE_J:  return _HE_J;
  1540. case XE:    return _XE;
  1541. case SIN:   return _SIN;
  1542. case SHIN:  return _SHIN;
  1543. case SAD:   return _SAD;
  1544. case ZAD:   return _ZAD;
  1546. case AYN:
  1547. case AYN_:
  1548. case _AYN:  return _AYN_;
  1550. case GHAYN:
  1551. case GHAYN_:
  1552. case _GHAYN_: return _GHAYN_;
  1554. case FE:    return _FE;
  1555. case GHAF:  return _GHAF;
  1556. case KAF:   return _KAF;
  1557. case GAF:   return _GAF;
  1558. case LAM:   return _LAM;
  1559. case MIM:   return _MIM;
  1560. case NOON:  return _NOON;
  1562. case _HE:
  1563. case F_HE: return _HE_;
  1565. case YE:
  1566. case YE_: return _YE;
  1568. case IE_:
  1569. case IE: return _IE;
  1571. case TEE: return TEE_;
  1573. case YEE:
  1574. case YEE_: return _YEE;
  1575.     }
  1576.     return c;
  1577. }
  1579. /*
  1580. ** Can a given Farsi character join via its left edj.
  1581. */
  1582.     static int
  1583. canF_Ljoin(c)
  1584.     int c;
  1585. {
  1586.     switch (c)
  1587.     {
  1588. case _BE:
  1589. case BE:
  1590. case PE:
  1591. case _PE:
  1592. case TE:
  1593. case _TE:
  1594. case SE:
  1595. case _SE:
  1596. case JIM:
  1597. case _JIM:
  1598. case CHE:
  1599. case _CHE:
  1600. case HE_J:
  1601. case _HE_J:
  1602. case XE:
  1603. case _XE:
  1604. case SIN:
  1605. case _SIN:
  1606. case SHIN:
  1607. case _SHIN:
  1608. case SAD:
  1609. case _SAD:
  1610. case ZAD:
  1611. case _ZAD:
  1612. case _TA:
  1613. case _ZA:
  1614. case AYN:
  1615. case _AYN:
  1616. case _AYN_:
  1617. case AYN_:
  1618. case GHAYN:
  1619. case GHAYN_:
  1620. case _GHAYN_:
  1621. case _GHAYN:
  1622. case FE:
  1623. case _FE:
  1624. case GHAF:
  1625. case _GHAF:
  1626. case _KAF_H:
  1627. case KAF:
  1628. case _KAF:
  1629. case GAF:
  1630. case _GAF:
  1631. case LAM:
  1632. case _LAM:
  1633. case MIM:
  1634. case _MIM:
  1635. case NOON:
  1636. case _NOON:
  1637. case IE:
  1638. case _IE:
  1639. case IE_:
  1640. case YE:
  1641. case _YE:
  1642. case YE_:
  1643. case YEE:
  1644. case _YEE:
  1645. case YEE_:
  1646. case F_HE:
  1647. case _HE:
  1648. case _HE_:
  1649.     return TRUE;
  1650.     }
  1651.     return FALSE;
  1652. }
  1654. /*
  1655. ** Can a given Farsi character join via its right edj.
  1656. */
  1657.     static int
  1658. canF_Rjoin(c)
  1659.     int     c;
  1660. {
  1661.     switch (c)
  1662.     {
  1663. case ALEF:
  1664. case ALEF_:
  1665. case ALEF_U_H:
  1666. case ALEF_U_H_:
  1667. case DAL:
  1668. case ZAL:
  1669. case RE:
  1670. case JE:
  1671. case ZE:
  1672. case TEE:
  1673. case TEE_:
  1674. case WAW:
  1675. case WAW_H:
  1676.     return TRUE;
  1677.     }
  1679.     return canF_Ljoin(c);
  1681. }
  1683. /*
  1684. ** is a given Farsi character a terminating type.
  1685. */
  1686.     static int
  1687. F_isterm(c)
  1688.     int     c;
  1689. {
  1690.     switch (c)
  1691.     {
  1692. case ALEF:
  1693. case ALEF_:
  1694. case ALEF_U_H:
  1695. case ALEF_U_H_:
  1696. case DAL:
  1697. case ZAL:
  1698. case RE:
  1699. case JE:
  1700. case ZE:
  1701. case WAW:
  1702. case WAW_H:
  1703. case TEE:
  1704. case TEE_:
  1705.     return TRUE;
  1706.     }
  1708.     return FALSE;
  1709. }
  1711. /*
  1712. ** Convert the given Farsi character into a ending type .
  1713. */
  1714.     static int
  1715. toF_ending(c)
  1716.     int     c;
  1717. {
  1719.     switch (c)
  1720.     {
  1721. case _BE:
  1722. return BE;
  1723. case _PE:
  1724. return PE;
  1725. case _TE:
  1726. return TE;
  1727. case _SE:
  1728. return SE;
  1729. case _JIM:
  1730. return JIM;
  1731. case _CHE:
  1732. return CHE;
  1733. case _HE_J:
  1734. return HE_J;
  1735. case _XE:
  1736. return XE;
  1737. case _SIN:
  1738. return SIN;
  1739. case _SHIN:
  1740. return SHIN;
  1741. case _SAD:
  1742. return SAD;
  1743. case _ZAD:
  1744. return ZAD;
  1745. case _AYN:
  1746. return AYN;
  1747. case _AYN_:
  1748. return AYN_;
  1749. case _GHAYN:
  1750. return GHAYN;
  1751. case _GHAYN_:
  1752. return GHAYN_;
  1753. case _FE:
  1754. return FE;
  1755. case _GHAF:
  1756. return GHAF;
  1757. case _KAF_H:
  1758. case _KAF:
  1759. return KAF;
  1760. case _GAF:
  1761. return GAF;
  1762. case _LAM:
  1763. return LAM;
  1764. case _MIM:
  1765. return MIM;
  1766. case _NOON:
  1767. return NOON;
  1768. case _YE:
  1769. return YE_;
  1770. case YE_:
  1771. return YE;
  1772. case _YEE:
  1773. return YEE_;
  1774. case YEE_:
  1775. return YEE;
  1776. case TEE:
  1777. return TEE_;
  1778. case _IE:
  1779. return IE_;
  1780. case IE_:
  1781. return IE;
  1782. case _HE:
  1783. case _HE_:
  1784. return F_HE;
  1785.     }
  1786.     return c;
  1787. }
  1789. /*
  1790. ** Convert the Farsi 3342 standard into Farsi VIM.
  1791. */
  1792.     void
  1793. conv_to_pvim()
  1794. {
  1795. char_u *ptr;
  1796. int lnum, llen, i;
  1798.     for (lnum = 1; lnum <= curbuf->b_ml.ml_line_count; ++lnum)
  1799.     {
  1800. ptr = ml_get((linenr_t)lnum);
  1802. llen = STRLEN(ptr);
  1804. for ( i = 0; i < llen-1; i++)
  1805. {
  1806.     if (canF_Ljoin(ptr[i]) && canF_Rjoin(ptr[i+1]))
  1807.     {
  1808. ptr[i] = toF_leading(ptr[i]);
  1809. ++i;
  1811. while(canF_Rjoin(ptr[i]) && (i < llen))
  1812. {
  1813.     ptr[i] = toF_Rjoin(ptr[i]);
  1814.     if (F_isterm(ptr[i]) || !F_isalpha(ptr[i]))
  1815. break;
  1816.     ++i;
  1817. }
  1818. if (!F_isalpha(ptr[i]) || !canF_Rjoin(ptr[i]))
  1819.     ptr[i-1] = toF_ending(ptr[i-1]);
  1820.     }
  1821.     else
  1822. ptr[i] = toF_TyA(ptr[i]);
  1823. }
  1824.     }
  1826.     /*
  1827.     ** Following lines contains Farsi encoded character.
  1828.     */
  1830.     do_cmdline((char_u *)"%s/202231/232/g", NULL, NULL, DOCMD_NOWAIT | DOCMD_VERBOSE);
  1831.     do_cmdline((char_u *)"%s/201231/370334/g", NULL, NULL, DOCMD_NOWAIT | DOCMD_VERBOSE);
  1833.     update_screen(CLEAR);
  1834.     MSG_ATTR(farsi_text_1, hl_attr(HLF_S));
  1835. }
  1837. /*
  1838. ** Convert the Farsi VIM into Farsi 3342 standad.
  1839. */
  1840.     void
  1841. conv_to_pstd()
  1842. {
  1843. char_u *ptr;
  1844. int lnum, llen, i;
  1846.     /*
  1847.     ** Following line contains Farsi encoded character.
  1848.     */
  1850.     do_cmdline((char_u *)"%s/232/202231/g", NULL, NULL, DOCMD_NOWAIT | DOCMD_VERBOSE);
  1852.     for (lnum = 1; lnum <= curbuf->b_ml.ml_line_count; ++lnum)
  1853.     {
  1854. ptr = ml_get((linenr_t)lnum);
  1856. llen = STRLEN(ptr);
  1858. for ( i = 0; i < llen; i++)
  1859. {
  1860.     ptr[i] = toF_TyA(ptr[i]);
  1862. }
  1863.     }
  1865.     update_screen(CLEAR);
  1866.     MSG_ATTR(farsi_text_2, hl_attr(HLF_S));
  1867. }
  1869. /*
  1870.  * left-right swap the characters in buf[len].
  1871.  */
  1872.     static void
  1873. lrswapbuf(buf, len)
  1874.     char_u *buf;
  1875.     int len;
  1876. {
  1877.     char_u *s, *e;
  1878.     int c;
  1880.     s = buf;
  1881.     e = buf + len - 1;
  1883.     while (e > s)
  1884.     {
  1885. c = *s;
  1886. *s = *e;
  1887. *e = c;
  1888. ++s;
  1889. --e;
  1890.     }
  1891. }
  1893. /*
  1894.  * swap all the characters in reverse direction
  1895.  */
  1896.     char_u *
  1897. lrswap(ibuf)
  1898.     char_u *ibuf;
  1899. {
  1900.     if (ibuf != NULL && *ibuf != NUL)
  1901. lrswapbuf(ibuf, (int)STRLEN(ibuf));
  1902.     return ibuf;
  1903. }
  1905. /*
  1906.  * swap all the Farsi characters in reverse direction
  1907.  */
  1908.     char_u *
  1909. lrFswap(cmdbuf, len)
  1910.     char_u *cmdbuf;
  1911.     int len;
  1912. {
  1913.     int i, cnt;
  1915.     if (cmdbuf == NULL)
  1916. return cmdbuf;
  1918.     if (len == 0 && (len = STRLEN(cmdbuf)) == 0)
  1919. return cmdbuf;
  1921.     for (i = 0; i < len; i++)
  1922.     {
  1923. for (cnt = 0; i + cnt < len
  1924. && (F_isalpha(cmdbuf[i + cnt])
  1925.     || F_isdigit(cmdbuf[i + cnt])
  1926.     || cmdbuf[i + cnt] == ' '); ++cnt)
  1927.     ;
  1929. lrswapbuf(cmdbuf + i, cnt);
  1930. i += cnt;
  1931.     }
  1932.     return cmdbuf;
  1933. }
  1935. /*
  1936.  * Reverse the characters in the seach path and substitude section accordingly
  1937.  */
  1938.     char_u *
  1939. lrF_sub(ibuf)
  1940.     char_u *ibuf;
  1941. {
  1942.     char_u *p, *ep;
  1943.     int i, cnt;
  1945.     p = ibuf;
  1947.     /* Find the boundry of the search path */
  1948.     while ((p = vim_strchr(++p, '/')) && p[-1] == '\')
  1949. ;
  1951.     if (p == NULL)
  1952. return ibuf;
  1954.     /* Reverse the Farsi characters in the search path. */
  1955.     lrFswap(ibuf, (int)(p-ibuf));
  1957.     /* Now find the boundry of the substitute section */
  1958.     if ((ep = (char_u *)strrchr((char *)++p, '/')))
  1959. cnt = ep - p;
  1960.     else
  1961. cnt = STRLEN(p);
  1963.     /* Reverse the characters in the substitute section and take care of '' */
  1964.     for (i = 0; i < cnt-1; i++)
  1965. if (p[i] == '\')
  1966. {
  1967.     p[i] = p[i+1] ;
  1968.     p[++i] = '\';
  1969. }
  1971.     lrswapbuf(p, cnt);
  1973.     return ibuf;
  1974. }
  1976. /*
  1977.  * Map Farsi keyboard when in cmd_fkmap mode.
  1978.  */
  1979.     int
  1980. cmdl_fkmap(c)
  1981.     int c;
  1982. {
  1983. int tempc;
  1985.     switch (c)
  1986.     {
  1987. case '0':
  1988. case '1':
  1989. case '2':
  1990. case '3':
  1991. case '4':
  1992. case '5':
  1993. case '6':
  1994. case '7':
  1995. case '8':
  1996. case '9':
  1997. case '`':
  1998. case ' ':
  1999. case '.':
  2000. case '!':
  2001. case '"':
  2002. case '$':
  2003. case '%':
  2004. case '^':
  2005. case '&':
  2006. case '/':
  2007. case '(':
  2008. case ')':
  2009. case '=':
  2010. case '\':
  2011. case '?':
  2012. case '+':
  2013. case '-':
  2014. case '_':
  2015. case '*':
  2016. case ':':
  2017. case '#':
  2018. case '~':
  2019. case '@':
  2020. case '<':
  2021. case '>':
  2022. case '{':
  2023. case '}':
  2024. case '|':
  2025. case 'B':
  2026. case 'E':
  2027. case 'F':
  2028. case 'H':
  2029. case 'I':
  2030. case 'K':
  2031. case 'L':
  2032. case 'M':
  2033. case 'O':
  2034. case 'P':
  2035. case 'Q':
  2036. case 'R':
  2037. case 'T':
  2038. case 'U':
  2039. case 'W':
  2040. case 'Y':
  2041. case  NL:
  2042. case  TAB:
  2044.        switch ((tempc = cmd_gchar(AT_CURSOR)))
  2045.        {
  2046.     case _BE:
  2047.     case _PE:
  2048.     case _TE:
  2049.     case _SE:
  2050.     case _JIM:
  2051.     case _CHE:
  2052.     case _HE_J:
  2053.     case _XE:
  2054.     case _SIN:
  2055.     case _SHIN:
  2056.     case _SAD:
  2057.     case _ZAD:
  2058.     case _AYN:
  2059.     case _GHAYN:
  2060.     case _FE:
  2061.     case _GHAF:
  2062.     case _KAF:
  2063.     case _GAF:
  2064.     case _LAM:
  2065.     case _MIM:
  2066.     case _NOON:
  2067.     case _HE:
  2068.     case _HE_:
  2069. cmd_pchar(toF_TyA(tempc), AT_CURSOR);
  2070. break;
  2071.     case _AYN_:
  2072. cmd_pchar(AYN_, AT_CURSOR);
  2073. break;
  2074.     case _GHAYN_:
  2075. cmd_pchar(GHAYN_, AT_CURSOR);
  2076. break;
  2077.     case _IE:
  2078. if (F_is_TyB_TyC_TyD(SRC_CMD, AT_CURSOR+1))
  2079.     cmd_pchar(IE_, AT_CURSOR);
  2080. else
  2081.     cmd_pchar(IE, AT_CURSOR);
  2082. break;
  2083.     case _YEE:
  2084. if (F_is_TyB_TyC_TyD(SRC_CMD, AT_CURSOR+1))
  2085.     cmd_pchar(YEE_, AT_CURSOR);
  2086. else
  2087.     cmd_pchar(YEE, AT_CURSOR);
  2088. break;
  2089.     case _YE:
  2090. if (F_is_TyB_TyC_TyD(SRC_CMD, AT_CURSOR+1))
  2091.     cmd_pchar(YE_, AT_CURSOR);
  2092. else
  2093.     cmd_pchar(YE, AT_CURSOR);
  2094.     }
  2096.     switch (c)
  2097.     {
  2098. case '0':   return FARSI_0;
  2099. case '1':   return FARSI_1;
  2100. case '2':   return FARSI_2;
  2101. case '3':   return FARSI_3;
  2102. case '4':   return FARSI_4;
  2103. case '5':   return FARSI_5;
  2104. case '6':   return FARSI_6;
  2105. case '7':   return FARSI_7;
  2106. case '8':   return FARSI_8;
  2107. case '9':   return FARSI_9;
  2108. case 'B':   return F_PSP;
  2109. case 'E':   return JAZR_N;
  2110. case 'F':   return ALEF_D_H;
  2111. case 'H':   return ALEF_A;
  2112. case 'I':   return TASH;
  2113. case 'K':   return F_LQUOT;
  2114. case 'L':   return F_RQUOT;
  2115. case 'M':   return HAMZE;
  2116. case 'O':   return '[';
  2117. case 'P':   return ']';
  2118. case 'Q':   return OO;
  2119. case 'R':   return MAD_N;
  2120. case 'T':   return OW;
  2121. case 'U':   return MAD;
  2122. case 'W':   return OW_OW;
  2123. case 'Y':   return JAZR;
  2124. case '`':   return F_PCN;
  2125. case '!':   return F_EXCL;
  2126. case '@':   return F_COMMA;
  2127. case '#':   return F_DIVIDE;
  2128. case '$':   return F_CURRENCY;
  2129. case '%':   return F_PERCENT;
  2130. case '^':   return F_MUL;
  2131. case '&':   return F_BCOMMA;
  2132. case '*':   return F_STAR;
  2133. case '(':   return F_LPARENT;
  2134. case ')':   return F_RPARENT;
  2135. case '-':   return F_MINUS;
  2136. case '_':   return F_UNDERLINE;
  2137. case '=':   return F_EQUALS;
  2138. case '+':   return F_PLUS;
  2139. case '\':  return F_BSLASH;
  2140. case '|':   return F_PIPE;
  2141. case ':':   return F_DCOLON;
  2142. case '"':   return F_SEMICOLON;
  2143. case '.':   return F_PERIOD;
  2144. case '/':   return F_SLASH;
  2145. case '<':   return F_LESS;
  2146. case '>':   return F_GREATER;
  2147. case '?':   return F_QUESTION;
  2148. case ' ':   return F_BLANK;
  2149.     }
  2151.     break;
  2153. case 'a':   return _SHIN;
  2154. case 'A':   return WAW_H;
  2155. case 'b':   return ZAL;
  2156. case 'c':   return ZE;
  2157. case 'C':   return JE;
  2158. case 'd':   return _YE;
  2159. case 'D':   return _YEE;
  2160. case 'e':   return _SE;
  2161. case 'f':   return _BE;
  2162. case 'g':   return _LAM;
  2163. case 'G':
  2164.     if (cmd_gchar(AT_CURSOR) == _LAM )
  2165. {
  2166.     cmd_pchar(LAM, AT_CURSOR);
  2167.     return ALEF_U_H;
  2168. }
  2170. if (F_is_TyB_TyC_TyD(SRC_CMD, AT_CURSOR))
  2171. return ALEF_U_H_;
  2172. else
  2173. return ALEF_U_H;
  2174. case 'h':
  2175.     if (cmd_gchar(AT_CURSOR) == _LAM )
  2176. {
  2177.     cmd_pchar(LA, AT_CURSOR);
  2178.     redrawcmdline();
  2179.     return K_IGNORE;
  2180. }
  2182. if (F_is_TyB_TyC_TyD(SRC_CMD, AT_CURSOR))
  2183. return ALEF_;
  2184. else
  2185. return ALEF;
  2186. case 'i':
  2187. if (F_is_TyB_TyC_TyD(SRC_CMD, AT_CURSOR))
  2188. return _HE_;
  2189. else
  2190. return _HE;
  2191. case 'j':   return _TE;
  2192. case 'J':
  2193. if (F_is_TyB_TyC_TyD(SRC_CMD, AT_CURSOR))
  2194. return TEE_;
  2195. else
  2196. return TEE;
  2197. case 'k':   return _NOON;
  2198. case 'l':   return _MIM;
  2199. case 'm':   return _PE;
  2200. case 'n':
  2201. case 'N':   return DAL;
  2202. case 'o':   return _XE;
  2203. case 'p':   return _HE_J;
  2204. case 'q':   return _ZAD;
  2205. case 'r':   return _GHAF;
  2206. case 's':   return _SIN;
  2207. case 'S':   return _IE;
  2208. case 't':   return _FE;
  2209. case 'u':
  2210. if (F_is_TyB_TyC_TyD(SRC_CMD, AT_CURSOR))
  2211. return _AYN_;
  2212. else
  2213. return _AYN;
  2214. case 'v':
  2215. case 'V':   return RE;
  2216. case 'w':   return _SAD;
  2217. case 'x':
  2218. case 'X':   return _TA;
  2219. case 'y':
  2220. if (F_is_TyB_TyC_TyD(SRC_CMD, AT_CURSOR))
  2221. return _GHAYN_;
  2222. else
  2223. return _GHAYN;
  2224. case 'z':
  2225. case 'Z':   return _ZA;
  2226. case ';':   return _KAF;
  2227. case ''':  return _GAF;
  2228. case ',':   return WAW;
  2229. case '[':   return _JIM;
  2230. case ']':   return _CHE;
  2231. }
  2233. return c;
  2234. }
  2236. /*
  2237.  * F_isalpha returns TRUE if 'c' is a Farsi alphabet
  2238.  */
  2239.     int
  2240. F_isalpha(c)
  2241.     int c;
  2242. {
  2243.     return (( c >= TEE_ && c <= _YE) ||
  2244. ( c >= ALEF_A && c <= YE) ||
  2245. ( c >= _IE && c <= YE_));
  2246. }
  2248. /*
  2249.  * F_isdigit returns TRUE if 'c' is a Farsi digit
  2250.  */
  2251.     int
  2252. F_isdigit(c)
  2253.     int     c;
  2254. {
  2255.     return (( c >= FARSI_0 && c <= FARSI_9 ));
  2256. }
  2258. /*
  2259.  * F_ischar returns TRUE if 'c' is a Farsi character.
  2260.  */
  2261.     int
  2262. F_ischar(c)
  2263.     int     c;
  2264. {
  2265.     return (( c >= TEE_ && c <= YE_));
  2266. }
  2268.     void
  2269. farsi_fkey(c)
  2270.     int     c;
  2271. {
  2272.     if (c == K_F8)
  2273.     {
  2274. if (p_altkeymap)
  2275. {
  2276.     if (curwin->w_p_pers & W_R_L)
  2277.     {
  2278. p_fkmap=0;
  2279. do_cmdline((char_u *)"set norl", NULL, NULL, DOCMD_NOWAIT);
  2280. MSG("");
  2281.     }
  2282.     else
  2283.     {
  2284. p_fkmap=1;
  2285. do_cmdline((char_u *)"set rl", NULL, NULL, DOCMD_NOWAIT);
  2286. MSG("");
  2287.     }
  2289.     curwin->w_p_pers = curwin->w_p_pers ^ W_R_L;
  2290. }
  2291.     }
  2293.     if (c == K_F9)
  2294.     {
  2295. if (p_altkeymap && curwin->w_p_rl)
  2296. {
  2297.     curwin->w_p_pers = curwin->w_p_pers ^ W_CONV;
  2298.     if (curwin->w_p_pers & W_CONV)
  2299. conv_to_pvim();
  2300.     else
  2301. conv_to_pstd();
  2302. }
  2303.     }
  2304. }