Category

Development Platform
Home > SourceCode/Document > Windows Develop > Windows Kernel > View Code
jislex.cpp
Package: shell.rar　[view]
Upload User: xhy777
Upload Date: 2007-02-14
Package Size: 24088k
Code Size: 17k
Category:

Windows Kernel

Development Platform:

Visual C++

jislex.cpp：Code Content
  1. /*----------------------------------------------------------------------------
  2. %%File: jislex.c
  3. %%Unit: fechmap
  4. %%Contact: jpick
  6. Simple converter for decoding a subset of possible ISO-2022-7 encoded
  7. files (ISO-2022).  Data is translated to and from Unicode.  Converter
  8. operates according to user options.
  10. Module currently handles ISO-2022-JP (and JIS) and ISO-2022-KR.  
  12. Converter is set up to handle ISO-2022-TW and ISO-2022-CN, but there
  13. are as yet no conversion tables for these.
  14. ----------------------------------------------------------------------------*/
  16. #include <stdio.h>
  17. #include <stddef.h>
  19. #include "private.h"
  20. #include "fechmap_.h"
  21. #include "lexint_.h"
  24. // State table for reading ISO-2022-7 encoded text
  25. //
  26. // Lexer recognizes the following designator sequences, used 
  27. // to select a one or two byte character set:
  28. //
  29. //    <esc> $ @ -- JIS C 6626-1978 (synonym of <esc> $ ( @)
  30. //    <esc> $ A -- GB 2312-80 (synonym of <esc> $ ( A)
  31. //    <esc> $ B -- JIS X 0208-1983 (synonym of <esc> $ ( B)
  32. //
  33. //    <esc> $ ( @ -- JIS C 6626-1978
  34. //    <esc> $ ( A -- GB 2312-80
  35. //    <esc> $ ( B -- JIS X 0208-1983
  36. //    <esc> $ ( C -- KS C 5601-1992
  37. //    <esc> $ ( D -- JIS X 0212-1990
  38. //    <esc> $ ( E -- ??? (ISO-IR-165:1992) ???
  39. //    <esc> $ ( G -- CNS 11643-1992 Plane 1
  40. //    <esc> $ ( H -- CNS 11643-1992 Plane 2
  41. //    <esc> $ ( I -- CNS 11643-1992 Plane 3
  42. //    <esc> $ ( J -- CNS 11643-1992 Plane 4
  43. //    <esc> $ ( K -- CNS 11643-1992 Plane 5
  44. //    <esc> $ ( L -- CNS 11643-1992 Plane 6
  45. //    <esc> $ ( M -- CNS 11643-1992 Plane 7
  46. //
  47. //    <esc> $ ) C -- KSC 5601-1987 (Implies ISO-2022-KR ??)
  48. //
  49. //    <esc> & @ <esc> $ B -- JIS X 0208-1990
  50. //
  51. //    <esc> ( B  -- Ascii
  52. //    <esc> ( H  -- Deprecated variant of JIS-Roman
  53. //    <esc> ( I  -- Half-Width Katakana
  54. //    <esc> ( J  -- JIS-Roman
  55. //    <esc> ( T  -- GB 1988-89 Roman
  56. //
  57. // Lexer recognizes the following shift sequences, used to allow
  58. // interpretation of a given byte or bytes:
  59. //
  60. //    <si> -- locking shift, interpret bytes as G0
  61. //    <so> -- locking shift, interpret bytes as G1
  62. //    <esc> n -- locking shift, interpret bytes as G2
  63. //    <esc> o -- locking shift, interpret bytes as G3
  64. //    <esc> N -- single shift, interpret bytes as G2
  65. //    <esc> O -- single shift, interpret bytes as G3
  66. //
  67. // REVIEW (jpick): don't currently need the final four shift
  68. //   sequences.  If we support ISO-2022-CN, we'll need to use
  69. //   G2 and G3 and potentially, then, the last four shifts.
  70. //
  72. /*----------------------------------------------------------------------------
  73. Character Classification Table
  74. ----------------------------------------------------------------------------*/
  76. // Tokens
  77. //
  78. #define txt (JTK) 0
  79. #define ext (JTK) 1 // extended characters that are legal under certain circumstances
  80. #define esc (JTK) 2
  81. #define si (JTK) 3
  82. #define so (JTK) 4
  83. #define dlr (JTK) 5
  84. #define at (JTK) 6
  85. #define amp (JTK) 7
  86. #define opr (JTK) 8
  87. #define cpr (JTK) 9
  88. #define tkA (JTK) 10
  89. #define tkB (JTK) 11
  90. #define tkC (JTK) 12
  91. #define tkD (JTK) 13
  92. #define tkE (JTK) 14
  93. #define tkG (JTK) 15
  94. #define tkH (JTK) 16
  95. #define tkI (JTK) 17
  96. #define tkJ (JTK) 18
  97. #define tkK (JTK) 19
  98. #define tkL (JTK) 20
  99. #define tkM (JTK) 21
  100. #define tkT (JTK) 22
  101. #define unk (JTK) 23 // Unexpected character
  102. #define eof (JTK) 24 // end-of-file
  103. #define err (JTK) 25 // read error
  105. #define nTokens 26
  107. // Lookup table for ISO-2022-7 encoded files
  108. //
  109. static JTK _rgjtkCharClass[256] =
  110. //  0    1    2    3    4    5    6    7    8    9    a    b    c    d    e    f
  111.     {
  112. //  nul  soh  stx  etx  eot  enq  ack  bel  bs   tab  lf   vt   np   cr   so   si 0
  113.     txt, txt, txt, txt, txt, txt, txt, txt, txt, txt, txt, txt, txt, txt, so,  si, 
  115. //  dle  dc1  dc2  dc3  dc4  nak  syn  etb  can  em   eof  esc  fs   gs   rs   us 1
  116.     txt, txt, txt, txt, txt, txt, txt, txt, txt, txt, txt, esc, txt, txt, txt, txt, 
  118. //  sp   !    "    #    $    %    &    '    (    )    *    +    ,    -    .    / 2
  119.     txt, txt, txt, txt, dlr, txt, amp, txt, opr, cpr, txt, txt, txt, txt, txt, txt, 
  121. //  0    1    2    3    4    5    6    7    8    9    :    ;    <    =    >    ? 3
  122.     txt, txt, txt, txt, txt, txt, txt, txt, txt, txt, txt, txt, txt, txt, txt, txt, 
  124. //  @    A    B    C    D    E    F    G    H    I    J    K    L    M    N    O 4
  125.     at,  tkA, tkB, tkC, tkD, tkE, txt, tkG, tkH, tkI, tkJ, tkK, tkL, tkM, txt, txt, 
  127. //  P    Q    R    S    T    U    V    W    X    Y    Z    [        ]    ^    _ 5
  128.     txt, txt, txt, txt, tkT, txt, txt, txt, txt, txt, txt, txt, txt, txt, txt, txt, 
  130. //  `    a    b    c    d    e    f    g    h    i    j    k    l    m    n    o 6
  131.     txt, txt, txt, txt, txt, txt, txt, txt, txt, txt, txt, txt, txt, txt, txt, txt, 
  133. //  p    q    r    s    t    u    v    w    x    y    z    {    |    }    ~    del 7
  134.     txt, txt, txt, txt, txt, txt, txt, txt, txt, txt, txt, txt, txt, txt, txt, txt, 
  136. //                 8
  137.     unk, unk, unk, unk, unk, unk, unk, unk, unk, unk, unk, unk, unk, unk, unk, unk, 
  139. //                 9
  140.     unk, unk, unk, unk, unk, unk, unk, unk, unk, unk, unk, unk, unk, unk, unk, unk, 
  142. //                 a
  143.     unk, ext, ext, ext, ext, ext, ext, ext, ext, ext, ext, ext, ext, ext, ext, ext, 
  145. //                 b
  146.     ext, ext, ext, ext, ext, ext, ext, ext, ext, ext, ext, ext, ext, ext, ext, ext, 
  148. //                 c
  149.     ext, ext, ext, ext, ext, ext, ext, ext, ext, ext, ext, ext, ext, ext, ext, ext, 
  151. //                 d
  152.     ext, ext, ext, ext, ext, ext, ext, ext, ext, ext, ext, ext, ext, ext, ext, ext, 
  154. //                 e
  155.     unk, unk, unk, unk, unk, unk, unk, unk, unk, unk, unk, unk, unk, unk, unk, unk, 
  157. //                 f
  158.     unk, unk, unk, unk, unk, unk, unk, unk, unk, unk, unk, unk, unk, unk, unk, unk, 
  160. //  0    1    2    3    4    5    6    7    8    9    a    b    c    d    e    f
  161. };
  164. /*----------------------------------------------------------------------------
  165. State Table
  166. ----------------------------------------------------------------------------*/
  168. // Final states have the high-bit set.  States that represent the reading
  169. // of a valid character escape sequence also encode the character set
  170. // "name" (moniker??) -- the state with the high bit masked off.
  171. //
  172. // Table State
  173. //
  174. typedef unsigned char TST;
  176. // Final State Mask, Related
  177. //
  178. #define grfFinal  (TST) 0x80
  179. #define _NEscTypeFromState(nState) (int) ((nState) & 0x7f)
  181. // ASCII Escape Sequence (Final State)
  182. #define ASC (TST) (grfFinal | 0x00) // Ascii
  184. // Japanese Escape Sequences (Final States)
  185. #define JS0 (TST) (grfFinal | 0x01) // JIS-Roman
  186. #define JS1 (TST) (grfFinal | 0x02) // Half-Width Katakana
  187. #define JS2  (TST) (grfFinal | 0x03) // JIS C 6226-1978
  188. #define JS3 (TST) (grfFinal | 0x04) // JIS X 0208-1983
  189. #define JS4 (TST) (grfFinal | 0x05) // JIS X 0208-1990
  190. #define JS5 (TST) (grfFinal | 0x06) // JIS X 0212-1990
  192. // Chinese (PRC) Escape Sequences (Final States)
  193. #define CS0 (TST) (grfFinal | 0x07) // GB 1988-89 Roman
  194. #define CS1 (TST) (grfFinal | 0x08) // GB 2312-80
  196. // Chinese (Taiwan) Escape Sequences (Final States)
  197. #define TS0 (TST) (grfFinal | 0x09) // CNS 11643-1992 Plane 1
  198. #define TS1 (TST) (grfFinal | 0x0a) // CNS 11643-1992 Plane 2
  199. #define TS2 (TST) (grfFinal | 0x0b) // CNS 11643-1992 Plane 3
  200. #define TS3 (TST) (grfFinal | 0x0c) // CNS 11643-1992 Plane 4
  201. #define TS4 (TST) (grfFinal | 0x0d) // CNS 11643-1992 Plane 5
  202. #define TS5 (TST) (grfFinal | 0x0e) // CNS 11643-1992 Plane 6
  203. #define TS6 (TST) (grfFinal | 0x0f) // CNS 11643-1992 Plane 7
  205. // Korean Escape Sequences (Final State)
  206. #define KS0 (TST) (grfFinal | 0x10) // KS C 5601-1992
  208. // Document "Signal" for ISO-2022-KR (Doc needs special processing)
  209. #define KSD (TST) (grfFinal | 0x11) // ISO-2022-KR Document Signal
  211. // Number of unique *character set* escape sequences
  212. //
  213. #define cCsEsc 18
  215. // Special States (not escape sequence) (Final States)
  216. //
  217. #define TXT (TST) (grfFinal | (cCsEsc + 1)) // Process Text
  218. #define EXT (TST) (grfFinal | (cCsEsc + 2)) // Process (Possibly Illegal) Extended Chars
  219. #define FIN (TST) (grfFinal | (cCsEsc + 3)) // Finish
  220. #define EOI (TST) (grfFinal | (cCsEsc + 4)) // Unexpected End-Of-Input
  221. #define UNK (TST) (grfFinal | (cCsEsc + 5)) // Unknown State (Unexpected Character)
  222. #define ERR (TST) (grfFinal | (cCsEsc + 6)) // Read Error
  224. // Shift Sequences (do not specify character set) (Final States)
  225. //
  226. #define LSO (TST) (grfFinal | (cCsEsc + 7)) // Locking shift out (g1 into GL)
  227. #define LSI (TST) (grfFinal | (cCsEsc + 8)) // Locking shift in (g0 into GL)
  229. // For convenience, also define constants for the sets
  230. // that the states represent.
  231. //
  232. #define csNIL (-1) // Invalid Designator
  233. #define csASC (_NEscTypeFromState(ASC)) // Ascii
  234. #define csJS0 (_NEscTypeFromState(JS0)) // JIS-Roman
  235. #define csJS1 (_NEscTypeFromState(JS1)) // Half-Width Katakana
  236. #define csJS2 (_NEscTypeFromState(JS2)) // JIS C 6226-1978
  237. #define csJS3 (_NEscTypeFromState(JS3)) // JIS X 0208-1983
  238. #define csJS4 (_NEscTypeFromState(JS4)) // JIS X 0208-1990
  239. #define csJS5 (_NEscTypeFromState(JS5)) // JIS X 0212-1990
  240. #define csCS0 (_NEscTypeFromState(CS0)) // GB 1988-89 Roman
  241. #define csCS1 (_NEscTypeFromState(CS1)) // GB 2312-80
  242. #define csTS0 (_NEscTypeFromState(TS0)) // CNS 11643-1992 Plane 1
  243. #define csTS1 (_NEscTypeFromState(TS1)) // CNS 11643-1992 Plane 2
  244. #define csTS2 (_NEscTypeFromState(TS2)) // CNS 11643-1992 Plane 3
  245. #define csTS3 (_NEscTypeFromState(TS3)) // CNS 11643-1992 Plane 4
  246. #define csTS4 (_NEscTypeFromState(TS4)) // CNS 11643-1992 Plane 5
  247. #define csTS5 (_NEscTypeFromState(TS5)) // CNS 11643-1992 Plane 6
  248. #define csTS6 (_NEscTypeFromState(TS6)) // CNS 11643-1992 Plane 7
  249. #define csKS0 (_NEscTypeFromState(KS0)) // KS C 5601-1992 (into G0)
  250. #define csKSD (_NEscTypeFromState(KSD)) // KS C 5601-1992 (into G1)
  252. // Table States (Intermediate States)
  253. #define ST0 (TST)  0
  254. #define ST1 (TST)  1
  255. #define ST2 (TST)  2
  256. #define ST3 (TST)  3
  257. #define ST4 (TST)  4
  258. #define ST5 (TST)  5
  259. #define ST6 (TST)  6
  260. #define ST7 (TST)  7
  261. #define ST8 (TST)  8
  262. #define ST9 (TST)  9
  264. // Number of "real" (table) states
  265. //
  266. #define nStates 10
  268. #define IsFinal(state) ((state) & grfFinal)
  271. // State Have Seen Looking For
  272. // ----------------------------------------------------------
  273. // ST0 -- Start State -- <ESC> Text
  274. // ST1 <ESC> $ & (
  275. // ST2 <ESC> $ ( ) @ A B   (**)
  276. // ST3 <ESC> $ ( @ A B C D E G H I J K L M
  277. // ST4 <ESC> $ ) C
  278. // ST5 <ESC> & @
  279. // ST6 <ESC> & @ <ESC>
  280. // ST7 <ESC> & @ <ESC> $
  281. // ST8 <ESC> & @ <ESC> $ B
  282. // ST9 <ESC> ( B H I J T
  283. //
  284. // (**)  "<ESC> $ ID" is a synonym of "<ESC> $ ( ID" for ID=(@, A, B)
  285. //
  286. // Because of the large number of tokens, this table is
  287. // inverted (tokens x states).
  288. //
  289. static signed char _rgchNextState[nTokens][nStates] =
  290. {
  291. //
  292. //           S     S     S     S     S     S     S     S     S     S 
  293. //           T     T     T     T     T     T     T     T     T     T  
  294. //           0     1     2     3     4     5     6     7     8     9   
  295. //--------------------------------------------------------------------
  296. //
  297. /* txt */  TXT,  UNK,  UNK,  UNK,  UNK,  UNK,  UNK,  UNK,  UNK,  UNK,
  298. /* ext */  EXT,  UNK,  UNK,  UNK,  UNK,  UNK,  UNK,  UNK,  UNK,  UNK,
  299. /* esc */  ST1,  UNK,  UNK,  UNK,  UNK,  UNK,  ST7,  UNK,  UNK,  UNK,
  300. /* si  */  LSI,  UNK,  UNK,  UNK,  UNK,  UNK,  UNK,  UNK,  UNK,  UNK,
  301. /* so  */  LSO,  UNK,  UNK,  UNK,  UNK,  UNK,  UNK,  UNK,  UNK,  UNK,
  302. /* $   */  TXT,  ST2,  UNK,  UNK,  UNK,  UNK,  UNK,  ST8,  UNK,  UNK,
  303. /* @   */  TXT,  UNK,  JS2,  JS2,  UNK,  ST6,  UNK,  UNK,  UNK,  UNK,
  304. /* &   */  TXT,  ST5,  UNK,  UNK,  UNK,  UNK,  UNK,  UNK,  UNK,  UNK,
  305. /* (   */  TXT,  ST9,  ST3,  UNK,  UNK,  UNK,  UNK,  UNK,  UNK,  UNK,
  306. /* )   */  TXT,  UNK,  ST4,  UNK,  UNK,  UNK,  UNK,  UNK,  UNK,  UNK,
  307. /* A   */  TXT,  UNK,  CS1,  CS1,  UNK,  UNK,  UNK,  UNK,  UNK,  UNK,
  308. /* B   */  TXT,  UNK,  JS3,  JS3,  UNK,  UNK,  UNK,  UNK,  JS4,  ASC,
  309. /* C   */  TXT,  UNK,  UNK,  KS0,  KSD,  UNK,  UNK,  UNK,  UNK,  UNK,
  310. /* D   */  TXT,  UNK,  UNK,  JS5,  UNK,  UNK,  UNK,  UNK,  UNK,  UNK,
  311. /* E   */  TXT,  UNK,  UNK,  UNK,  UNK,  UNK,  UNK,  UNK,  UNK,  UNK,
  312. /* G   */  TXT,  UNK,  UNK,  TS0,  UNK,  UNK,  UNK,  UNK,  UNK,  UNK,
  313. /* H   */  TXT,  UNK,  UNK,  TS1,  UNK,  UNK,  UNK,  UNK,  UNK,  JS0,
  314. /* I   */  TXT,  UNK,  UNK,  TS2,  UNK,  UNK,  UNK,  UNK,  UNK,  JS1,
  315. /* J   */  TXT,  UNK,  UNK,  TS3,  UNK,  UNK,  UNK,  UNK,  UNK,  JS0,
  316. /* K   */  TXT,  UNK,  UNK,  TS4,  UNK,  UNK,  UNK,  UNK,  UNK,  UNK,
  317. /* L   */  TXT,  UNK,  UNK,  TS5,  UNK,  UNK,  UNK,  UNK,  UNK,  UNK,
  318. /* M   */  TXT,  UNK,  UNK,  TS6,  UNK,  UNK,  UNK,  UNK,  UNK,  UNK,
  319. /* T   */  TXT,  UNK,  UNK,  UNK,  UNK,  UNK,  UNK,  UNK,  UNK,  CS0,
  320. /* unk */  UNK,  UNK,  UNK,  UNK,  UNK,  UNK,  UNK,  UNK,  UNK,  UNK,
  321. /* eof */  FIN,  EOI,  EOI,  EOI,  EOI,  EOI,  EOI,  EOI,  EOI,  EOI,
  322. /* err */  ERR,  ERR,  ERR,  ERR,  ERR,  ERR,  ERR,  ERR,  ERR,  ERR,
  323. };
  326. // Also for ISO-2022 out.  Build arrays of possible character
  327. // sets for each type of input character set.  Character sets
  328. // should appear in order of hit probability (e.g., in 2022-Jp
  329. // JS3 is the most common set).  Mark the end of array with -1.
  330. // (Only store these for non-ascii sets).
  331. //
  332. //
  333. // China (icetIso2022Cn)
  334. static int _rgceCn[] = { -1, };
  336. // Japan (icetIso2022Jp)
  337. static int _rgceJp[] = { csJS3, csJS1, csJS5, -1, };
  339. // Korea (icetIso2022Kr)
  340. static int _rgceKr[] = { -1, };
  342. // Taiwan (icetIso2022Tw)
  343. static int _rgceTw[] = { -1, };
  345. static int *_mpicetrgce[icetCount] =
  346. {
  347. 0, // icetEucCn
  348. 0, // icetEucJp
  349. 0, // icetEucKr
  350. 0, // icetEucTw
  351. _rgceCn, // icetIso2022Cn
  352. _rgceJp, // icetIso2022Jp
  353. _rgceKr, // icetIso2022Kr
  354. _rgceTw, // icetIso2022Tw
  355. 0, // icetBig5
  356. 0, // icetGbk
  357. 0, // icetShiftJis
  358. 0, // icetWansung
  359. 0, // icetUtf8
  360. };
  362. /* _ J T K  G E T  N E X T */
  363. /*----------------------------------------------------------------------------
  364. %%Function: _JtkGetNext
  365. %%Contact: jpick
  367. Get the next character and classify it.  Return the token.
  368. ----------------------------------------------------------------------------*/
  369. static JTK __inline _JtkGetNext(IStream *pstmIn, PUCHAR puch)
  370. {
  371. ULONG rc;
  372.     HRESULT hr;
  373.   
  374.     hr = pstmIn->Read(puch, 1, &rc);
  376. if (hr != S_OK )
  377. return err;
  378. else if (rc == 0)
  379. return eof;
  380. else
  381. return _rgjtkCharClass[*puch];
  382. }
  384. /* C C E  R E A D  E S C  S E Q */
  385. /*----------------------------------------------------------------------------
  386. %%Function: CceReadEscSeq
  387. %%Contact: jpick
  389. Read pointer is positioned at an escape sequence, figure out
  390. which escape sequence it is.
  391. ----------------------------------------------------------------------------*/
  392. CCE CceReadEscSeq(IStream *pstmIn, ICET *lpicet)
  393. {
  394.     UCHAR uch;
  395. TST tstCurr;
  396. JTK jtk;
  397. CCE cceRet;
  398. #ifdef DEBUG
  399. TST tstPrev;
  400. #endif
  402. // Sanity checks ...
  403. //
  404. #ifdef DEBUG
  405. if (!pstmIn || !lpicet)
  406. return cceInvalidParameter;
  407. #endif
  409. tstCurr = ST0;
  411. while (1)
  412. {
  413. // Find the next stopping state.
  414. //
  415. do
  416. {
  417. // Get the next character and clasify it.
  418. //
  419. jtk = _JtkGetNext(pstmIn, &uch);
  421. #ifdef DEBUG
  422. // Save the previous state for debugging purposes, only.
  423. //
  424. tstPrev = tstCurr;
  425. #endif
  426. // Transition -- note that order is different than
  427. // "normal" transition tables.
  428. //
  429. tstCurr = _rgchNextState[jtk][tstCurr];
  431. } while (!IsFinal(tstCurr));
  433. switch (tstCurr)
  434. {
  435. case JS0: // JIS-Roman
  436. case JS1: // Half-Width Katakana
  437. case JS2: // JIS C 6226-1978
  438. case JS3: // JIS X 0208-1983
  439. case JS4: // JIS X 0208-1990
  440. case JS5: // JIS X 0212-1990
  441. *lpicet = icetIso2022Jp;
  442. cceRet = cceSuccess;
  443. goto _LRet;
  444. case CS0: // GB 1988-89 Roman
  445. case CS1: // GB 2312-80
  446. *lpicet = icetIso2022Cn;
  447. cceRet = cceSuccess;
  448. goto _LRet;
  449. case TS0: // CNS 11643-1992 Plane 1
  450. case TS1: // CNS 11643-1992 Plane 2
  451. case TS2: // CNS 11643-1992 Plane 3
  452. case TS3: // CNS 11643-1992 Plane 4
  453. case TS4: // CNS 11643-1992 Plane 5
  454. case TS5: // CNS 11643-1992 Plane 6
  455. case TS6: // CNS 11643-1992 Plane 7
  456. *lpicet = icetIso2022Tw;
  457. cceRet = cceSuccess;
  458. goto _LRet;
  459. case KS0: // KS C 5601-1992
  460. case KSD: // ISO-2022-KR Document Signal
  461. *lpicet = icetIso2022Kr;
  462. cceRet = cceSuccess;
  463. goto _LRet;
  464. case ASC: // Ascii
  465. case LSO:
  466. case LSI:
  467. case TXT:
  468. case EXT:
  469. case FIN:
  470. // Insufficient information to choose a flavor ...
  471. cceRet = cceMayBeAscii;
  472. goto _LRet;
  473. case ERR:
  474. cceRet = cceRead;
  475. goto _LRet;
  476. default: // UNK, EOI
  477. cceRet = cceUnknownInput;
  478. goto _LRet;
  479. }
  480. }
  482. _LRet:
  484. return cceRet;
  485. }