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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多国语言处理 > 查看源码
GETCODE.CPP
资源名称：ChineseScape.zip　[点击查看]
上传用户：zhang8947
上传日期：2007-01-08
资源大小：1910k
文件大小：17k
源码类别：

多国语言处理

开发平台：

Visual C++

GETCODE.CPP：源码内容
  1. //各种内码输入法
  3. #include "stdafx.h"
  5. #include "cspublic.h"
  7. #include "csinput.h"
  8. #include "getcode.h"
  10. static unsigned char c1 , c2 ; //记录翻页位置
  11. int nPages , nPageStep ; //记录翻页次数和最后一次翻页的步长
  13. //把16进制字符转换成10进制整型
  14. int CharToInt( char c )
  15. {
  16. if( c>='0' && c<='9' ) //是数字
  17. return( c-'0' ) ;
  18. if( c>='a' && c<='f' ) //是16进制数
  19. return( c-'a'+10 ) ;
  20. if( c>='A' && c<='F' )
  21. return( c-'A'+10 ) ;
  22. return -1 ;
  23. }
  25. //-------------------------------------------------------------------------------------------------------//
  26. //判断GB内码是否合法
  27. BOOL JudgeGBCode( LPCSTR lpcsInput , int nLenOfInput )
  28. {
  29. int n ;
  31. switch( nLenOfInput )
  32. {
  33. case 1: //左边第一位
  34. n =CharToInt( lpcsInput[0] ) ;
  35. if( n>=0xa && n<=0xf )
  36. return 1 ;
  37. return 0 ;
  38. case 2: //左边第二位
  39. n =CharToInt( lpcsInput[0] )*16+CharToInt( lpcsInput[1] ) ;
  40. if( (n>=0xa1 && n<=0xa9) || (n>=0xb0 && n<=0xf7) )
  41. return 1 ;
  42. return 0 ;
  43. case 3: //左边第三位
  44. //先判断第一字节
  45. n =CharToInt( lpcsInput[0] )*16+CharToInt( lpcsInput[1] ) ;
  46. if( !((n>=0xa1 && n<=0xa9) || (n>=0xb0 && n<=0xf7)) )
  47. return 0 ;
  49. n =CharToInt( lpcsInput[2] ) ;
  50. if( n>=0xa && n<=0xf )
  51. return 1 ;
  52. return 0 ;
  53. case 4: //左边第四位
  54. //先判断第一字节
  55. n =CharToInt( lpcsInput[0] )*16+CharToInt( lpcsInput[1] ) ;
  56. if( !((n>=0xa1 && n<=0xa9) || (n>=0xb0 && n<=0xf7)) )
  57. return 0 ;
  59. n =CharToInt( lpcsInput[2] )*16+CharToInt( lpcsInput[3] ) ;
  60. if( n>=0xa1 && n<=0xfe )
  61. return 1 ;
  62. return 0 ;
  63. }
  65. return 0 ;
  66. }
  68. //根据c1,c2,得到GB码的下一个代码,c1,c2必须正确
  69. BOOL GetNextGBCode( void )
  70. {
  71. if( c2==0xfe ) //c2已经到头
  72. {
  73. if( c1==0xf7 ) //c1也已经到头
  74. return 0 ;
  75. c2 =0xa1 ;
  76. if( c1==0xa9 )
  77. c1 =0xb0 ;
  78. else
  79. c1++ ;
  80. }
  81. else
  82. c2++ ;
  84. return 1 ;
  85. }
  87. //根据c1,c2,得到GB码的上一个代码,c1,c2必须正确
  88. BOOL GetPriorGBCode( void )
  89. {
  90. if( c2==0xa1 ) //c2已经到头
  91. {
  92. if( c1==0xa1 ) //c1也已经到头
  93. return 0 ;
  94. c2 =0xfe ;
  95. if( c1==0xb0 )
  96. c1 =0xa9 ;
  97. else
  98. c1-- ;
  99. }
  100. else
  101. c2-- ;
  103. return 1 ;
  104. }
  106. //初始GB的c1,c2
  107. void InitGBC1C2( LPCSTR lpcsInput , int nLenOfInput )
  108. {
  109. int n ;
  111. switch( nLenOfInput )
  112. {
  113. case 1:
  114. n =CharToInt( lpcsInput[0] ) ;
  115. if( n==0xa )
  116. c1 =0xa1 ;
  117. else
  118. c1 =n*16 ;
  119. c2 =0xa1 ;
  120. break ;
  121. case 2:
  122. c1 =CharToInt( lpcsInput[0] )*16 + CharToInt( lpcsInput[1] ) ;
  123. c2 =0xa1 ;
  124. break ;
  125. case 3:
  126. c1 =CharToInt( lpcsInput[0] )*16 + CharToInt( lpcsInput[1] ) ;
  127. n =CharToInt( lpcsInput[2] ) ;
  128. if( n==0xa )
  129. c2 =0xa1 ;
  130. else
  131. c2 =n*16 ;
  132. break ;
  133. }
  134. }
  135. //-----------------------------------------------------------------------------------------------//
  136. //判断BIG5内码是否合法
  137. BOOL JudgeBig5Code( LPCSTR lpcsInput , int nLenOfInput )
  138. {
  139. int n ;
  141. switch( nLenOfInput )
  142. {
  143. case 1: //左边第一位
  144. n =CharToInt( lpcsInput[0] ) ;
  145. if( n>=0xa && n<=0xf )
  146. return 1 ;
  147. return 0 ;
  148. case 2: //左边第二位
  149. n =CharToInt( lpcsInput[0] )*16+CharToInt( lpcsInput[1] ) ;
  150. if( n>=0xa1 && n<=0xf9)
  151. return 1 ;
  152. return 0 ;
  153. case 3: //左边第三位
  154. //先判断第一字节
  155. n =CharToInt( lpcsInput[0] )*16+CharToInt( lpcsInput[1] ) ;
  156. if( n<0xa1 || n>0xf9)
  157. return 0 ;
  159. n =CharToInt( lpcsInput[2] ) ;
  160. if( n>=0x4 && n<=0xf )
  161. return 1 ;
  162. return 0 ;
  163. case 4: //左边第四位
  164. //先判断第一字节
  165. n =CharToInt( lpcsInput[0] )*16+CharToInt( lpcsInput[1] ) ;
  166. if( n<0xa1 || n>0xf9)
  167. return 0 ;
  169. n =CharToInt( lpcsInput[2] )*16+CharToInt( lpcsInput[3] ) ;
  170. if( n>=0x40 && n<=0xfe )
  171. return 1 ;
  172. return 0 ;
  173. }
  175. return 0 ;
  176. }
  178. //根据c1,c2,得到BIG5码的下一个代码,c1,c2必须正确
  179. BOOL GetNextBig5Code( void )
  180. {
  181. if( c2==0xfe ) //c2已经到头
  182. {
  183. if( c1==0xf9 ) //c1也已经到头
  184. return 0 ;
  185. c2 =0x40 ;
  186. c1++ ;
  187. }
  188. else
  189. c2++ ;
  191. return 1 ;
  192. }
  194. //根据c1,c2,得到BIG5码的上一个代码,c1,c2必须正确
  195. BOOL GetPriorBig5Code( void )
  196. {
  197. if( c2==0x40 ) //c2已经到头
  198. {
  199. if( c1==0xa1 ) //c1也已经到头
  200. return 0 ;
  201. c2 =0xfe ;
  202. c1-- ;
  203. }
  204. else
  205. c2-- ;
  207. return 1 ;
  208. }
  210. //初始BIG5的c1,c2
  211. void InitBig5C1C2( LPCSTR lpcsInput , int nLenOfInput )
  212. {
  213. int n ;
  215. switch( nLenOfInput )
  216. {
  217. case 1:
  218. n =CharToInt( lpcsInput[0] ) ;
  219. if( n==0xa )
  220. c1 =0xa1 ;
  221. else
  222. c1 =n*16 ;
  223. c2 =0x40 ;
  224. break ;
  225. case 2:
  226. c1 =CharToInt( lpcsInput[0] )*16 + CharToInt( lpcsInput[1] ) ;
  227. c2 =0x40 ;
  228. break ;
  229. case 3:
  230. c1 =CharToInt( lpcsInput[0] )*16 + CharToInt( lpcsInput[1] ) ;
  231. n =CharToInt( lpcsInput[2] ) ;
  232. c2 =n*16 ;
  233. break ;
  234. }
  235. }
  236. //-----------------------------------------------------------------------------------------//
  237. //判断SHIFT-JIS内码是否合法
  238. BOOL JudgeShiftJisCode( LPCSTR lpcsInput , int nLenOfInput )
  239. {
  240. int n , n1 ;
  242. switch( nLenOfInput )
  243. {
  244. case 1: //左边第一位
  245. n =CharToInt( lpcsInput[0] ) ;
  246. if( n>=0x8 && n<=0xe )
  247. return 1 ;
  248. return 0 ;
  249. case 2: //左边第二位
  250. n =CharToInt( lpcsInput[0] )*16+CharToInt( lpcsInput[1] ) ;
  251. if( n>=0x81 && n<=0xea)
  252. return 1 ;
  253. return 0 ;
  254. case 3: //左边第三位
  255. //先判断第一字节
  256. n =CharToInt( lpcsInput[0] )*16+CharToInt( lpcsInput[1] ) ;
  257. if( n<0x81 || n>0xea)
  258. return 0 ;
  260. n =CharToInt( lpcsInput[2] ) ;
  261. if( n>=0x4 && n<=0xf )
  262. return 1 ;
  263. return 0 ;
  264. case 4: //左边第四位
  265. //先判断第一字节
  266. n =CharToInt( lpcsInput[0] )*16+CharToInt( lpcsInput[1] ) ;
  267. if( n<0x81 || n>0xea)
  268. return 0 ;
  270. n1 =CharToInt( lpcsInput[2] )*16+CharToInt( lpcsInput[3] ) ;
  271. if( n==0xea )
  272. {
  273. if( n1!=0x7f && n1>=0x40 && n1<=0xa2 )
  274. return 1 ;
  275. return 0 ;
  276. }
  277. if( n1!=0x7f && n1>=0x40 && n1<=0xfc )
  278. return 1 ;
  279. return 0 ;
  280. }
  282. return 0 ;
  283. }
  285. //根据c1,c2,得到SHIFT-JIS码的下一个代码,c1,c2必须正确
  286. BOOL GetNextShiftJisCode( void )
  287. {
  288. if( c2==0xfc ) //c2已经到头
  289. {
  290. if( c1==0xea ) //c1也已经到头
  291. return 0 ;
  292. c2 =0x40 ;
  293. c1++ ;
  294. }
  295. else
  296. {
  297. if( c1==0xea && c2==0xa2 ) //已经到头
  298. return 0 ;
  299. c2++ ;
  300. if( c2==0x7f )
  301. c2++ ; //跳过0x7f
  302. }
  304. return 1 ;
  305. }
  307. //根据c1,c2,得到Shift-Jis码的上一个代码,c1,c2必须正确
  308. BOOL GetPriorShiftJisCode( void )
  309. {
  310. if( c2==0x40 ) //c2已经到头
  311. {
  312. if( c1==0x81 ) //c1也已经到头
  313. return 0 ;
  314. c2 =0xfc ;
  315. c1-- ;
  316. }
  317. else
  318. c2-- ;
  320. return 1 ;
  321. }
  323. //初始Shift-Jis的c1,c2
  324. void InitShiftJisC1C2( LPCSTR lpcsInput , int nLenOfInput )
  325. {
  326. int n ;
  328. switch( nLenOfInput )
  329. {
  330. case 1:
  331. n =CharToInt( lpcsInput[0] ) ;
  332. if( n==0x8 )
  333. c1 =0x81 ;
  334. else
  335. c1 =n*16 ;
  336. c2 =0x40 ;
  337. break ;
  338. case 2:
  339. c1 =CharToInt( lpcsInput[0] )*16 + CharToInt( lpcsInput[1] ) ;
  340. c2 =0x40 ;
  341. break ;
  342. case 3:
  343. c1 =CharToInt( lpcsInput[0] )*16 + CharToInt( lpcsInput[1] ) ;
  344. n =CharToInt( lpcsInput[2] ) ;
  345. c2 =n*16 ;
  346. break ;
  347. }
  348. }
  349. //------------------------------------------------------------------------------------------------//
  351. //判断EUC-JIS内码是否合法
  352. BOOL JudgeEucJisCode( LPCSTR lpcsInput , int nLenOfInput )
  353. {
  354. int n , n1 ;
  356. switch( nLenOfInput )
  357. {
  358. case 1: //左边第一位
  359. n =CharToInt( lpcsInput[0] ) ;
  360. if( n>=0xa && n<=0xf )
  361. return 1 ;
  362. return 0 ;
  363. case 2: //左边第二位
  364. n =CharToInt( lpcsInput[0] )*16+CharToInt( lpcsInput[1] ) ;
  365. if( n>=0xa1 && n<=0xf4 )
  366. return 1 ;
  367. return 0 ;
  368. case 3: //左边第三位
  369. //先判断第一字节
  370. n =CharToInt( lpcsInput[0] )*16+CharToInt( lpcsInput[1] ) ;
  371. if( n<0xa1 || n>0xf4 )
  372. return 0 ;
  374. n =CharToInt( lpcsInput[2] ) ;
  375. if( n>=0xa && n<=0xf )
  376. return 1 ;
  377. return 0 ;
  378. case 4: //左边第四位
  379. //先判断第一字节
  380. n =CharToInt( lpcsInput[0] )*16+CharToInt( lpcsInput[1] ) ;
  381. if( n<0xa1 && n>0xf4 )
  382. return 0 ;
  384. n1 =CharToInt( lpcsInput[2] )*16+CharToInt( lpcsInput[3] ) ;
  385. if( n==0xf4 )
  386. {
  387. if( n1>=0xa1 && n1<=0xa4 )
  388. return 1 ;
  389. return 0 ;
  390. }
  391. if( n>=0xa1 && n<=0xfe )
  392. return 1 ;
  393. return 0 ;
  394. }
  396. return 0 ;
  397. }
  399. //根据c1,c2,得到EUC-JIS码的下一个代码,c1,c2必须正确
  400. BOOL GetNextEucJisCode( void )
  401. {
  402. if( c2==0xfe ) //c2已经到头
  403. {
  404. if( c1==0xf4 ) //c1也已经到头
  405. return 0 ;
  406. c2 =0xa1 ;
  407. c1++ ;
  408. }
  409. else
  410. {
  411. if( c1==0xf4 && c2==0xa4 ) //已经到头
  412. return 0 ;
  413. c2++ ;
  414. }
  416. return 1 ;
  417. }
  419. //根据c1,c2,得到EUC-JIS码的上一个代码,c1,c2必须正确
  420. BOOL GetPriorEucJisCode( void )
  421. {
  422. if( c2==0xa1 ) //c2已经到头
  423. {
  424. if( c1==0xa1 ) //c1也已经到头
  425. return 0 ;
  426. c2 =0xfe ;
  427. c1-- ;
  428. }
  429. else
  430. c2-- ;
  432. return 1 ;
  433. }
  435. //初始EUC-JIS的c1,c2
  436. void InitEucJisC1C2( LPCSTR lpcsInput , int nLenOfInput )
  437. {
  438. int n ;
  440. switch( nLenOfInput )
  441. {
  442. case 1:
  443. n =CharToInt( lpcsInput[0] ) ;
  444. if( n==0xa )
  445. c1 =0xa1 ;
  446. else
  447. c1 =n*16 ;
  448. c2 =0xa1 ;
  449. break ;
  450. case 2:
  451. c1 =CharToInt( lpcsInput[0] )*16 + CharToInt( lpcsInput[1] ) ;
  452. c2 =0xa1 ;
  453. break ;
  454. case 3:
  455. c1 =CharToInt( lpcsInput[0] )*16 + CharToInt( lpcsInput[1] ) ;
  456. n =CharToInt( lpcsInput[2] ) ;
  457. if( n==0xa )
  458. c2 =0xa1 ;
  459. else
  460. c2 =n*16 ;
  461. break ;
  462. }
  463. }
  464. //-----------------------------------------------------------------------------------------------//
  466. //判断KSC5601内码是否合法
  467. BOOL JudgeKsc5601Code( LPCSTR lpcsInput , int nLenOfInput )
  468. {
  469. int n ;
  471. switch( nLenOfInput )
  472. {
  473. case 1: //左边第一位
  474. n =CharToInt( lpcsInput[0] ) ;
  475. if( n>=0xa && n<=0xf )
  476. return 1 ;
  477. return 0 ;
  478. case 2: //左边第二位
  479. n =CharToInt( lpcsInput[0] )*16+CharToInt( lpcsInput[1] ) ;
  480. if( n>=0xa1 && n<=0xfd)
  481. return 1 ;
  482. return 0 ;
  483. case 3: //左边第三位
  484. //先判断第一字节
  485. n =CharToInt( lpcsInput[0] )*16+CharToInt( lpcsInput[1] ) ;
  486. if( n<0xa1 || n>0xfd)
  487. return 0 ;
  489. n =CharToInt( lpcsInput[2] ) ;
  490. if( n>=0xa && n<=0xf )
  491. return 1 ;
  492. return 0 ;
  493. case 4: //左边第四位
  494. //先判断第一字节
  495. n =CharToInt( lpcsInput[0] )*16+CharToInt( lpcsInput[1] ) ;
  496. if( n<0xa1 || n>0xfd)
  497. return 0 ;
  499. n =CharToInt( lpcsInput[2] )*16+CharToInt( lpcsInput[3] ) ;
  500. if( n>=0xa1 && n<=0xfe )
  501. return 1 ;
  502. return 0 ;
  503. }
  505. return 0 ;
  506. }
  508. //根据c1,c2,得到KSC5601码的下一个代码,c1,c2必须正确
  509. BOOL GetNextKsc5601Code( void )
  510. {
  511. if( c2==0xfe ) //c2已经到头
  512. {
  513. if( c1==0xfd ) //c1也已经到头
  514. return 0 ;
  515. c2 =0xa1 ;
  516. c1++ ;
  517. }
  518. else
  519. c2++ ;
  521. return 1 ;
  522. }
  524. //根据c1,c2,得到KSC5601码的上一个代码,c1,c2必须正确
  525. BOOL GetPriorKsc5601Code( void )
  526. {
  527. if( c2==0xa1 ) //c2已经到头
  528. {
  529. if( c1==0xa1 ) //c1也已经到头
  530. return 0 ;
  531. c2 =0xfe ;
  532. c1-- ;
  533. }
  534. else
  535. c2-- ;
  537. return 1 ;
  538. }
  540. //初始KSC5601的c1,c2
  541. void InitKsc5601C1C2( LPCSTR lpcsInput , int nLenOfInput )
  542. {
  543. int n ;
  545. switch( nLenOfInput )
  546. {
  547. case 1:
  548. n =CharToInt( lpcsInput[0] ) ;
  549. if( n==0xa )
  550. c1 =0xa1 ;
  551. else
  552. c1 =n*16 ;
  553. c2 =0xa1 ;
  554. break ;
  555. case 2:
  556. c1 =CharToInt( lpcsInput[0] )*16 + CharToInt( lpcsInput[1] ) ;
  557. c2 =0xa1 ;
  558. break ;
  559. case 3:
  560. c1 =CharToInt( lpcsInput[0] )*16 + CharToInt( lpcsInput[1] ) ;
  561. n =CharToInt( lpcsInput[2] ) ;
  562. if( n==0xa )
  563. c2 =0xa1 ;
  564. else
  565. c2 =n*16 ;
  566. break ;
  567. }
  568. }
  569. //-----------------------------------------------------------------------------------------------//
  571. //内码输入法向下翻页
  572. //返回0:出错或者输入字符不合法
  573. //返回1:只可以向下翻页
  574. //返回2:只可以向上翻页
  575. //返回3:可以向下也可以向上翻页
  576. //返回4:不能进行翻页
  577. int PageNext(  LPCSTR lpcsInput , int nLenOfInput , //输入串和长度
  578. LPSTR lpsOutput , LPINT lpnLenOfOutput ) //输出串和长度
  579. {
  580. int n , i , n1 ;
  582. switch( nLenOfInput )
  583. {
  584. case 1: //只输入了一个字符,除了该字符都可以改变
  585. n =CharToInt( lpcsInput[0] ) ; //得到已经输入的字符值
  586. for( i=0 ; i<10 ; i++ )
  587. {
  588. lpsOutput[i*4] =i+'0' ;
  589. //返回这个编码
  590. lpsOutput[i*4+1] =c1 ;
  591. lpsOutput[i*4+2] =c2 ;
  592. if( i<9 )
  593. lpsOutput[i*4+3] =' ' ;
  595. //得到下一个编码
  596. if( !GetNextCode() ) //已经没有下一个编码了
  597. {
  598. *lpnLenOfOutput =(i+1)*4-1 ;
  599. nPages++ ;
  600. nPageStep =i+1 ;
  601. return 2 ; //只可以向前翻页  
  602. }
  603. //判断下一个编码是否合法
  604. if( (c1/16) != n ) //不合法
  605. {
  606. *lpnLenOfOutput =(i+1)*4-1 ;
  607. nPages++ ;
  608. nPageStep =i+1 ;
  609. return 2 ; //只可以向前翻页  
  610. }
  611. }
  612. *lpnLenOfOutput =i*4-1 ;
  613. nPages++ ;
  614. nPageStep =i ;
  615. return 3 ;
  616. case 2: //只输入了两个字符,除了这两个字符都可以改变
  617. n =c1 ; //不能改变第一个字节
  618. for( i=0 ; i<10 ; i++ )
  619. {
  620. lpsOutput[i*4] =i+'0' ;
  621. //返回这个编码
  622. lpsOutput[i*4+1] =c1 ;
  623. lpsOutput[i*4+2] =c2 ;
  624. if( i<9 )
  625. lpsOutput[i*4+3] =' ' ;
  627. //得到下一个编码
  628. if( !GetNextCode() ) //已经没有下一个编码了
  629. {
  630. *lpnLenOfOutput =(i+1)*4-1 ;
  631. nPages++ ;
  632. nPageStep =i+1 ;
  633. return 2 ; //只可以向前翻页  
  634. }
  635. //判断下一个编码是否合法
  636. if( c1 != n ) //不合法
  637. {
  638. *lpnLenOfOutput =(i+1)*4-1 ;
  639. nPages++ ;
  640. nPageStep =i+1 ;
  641. return 2 ; //只可以向前翻页  
  642. }
  643. }
  644. *lpnLenOfOutput =i*4-1 ;
  645. nPages++ ;
  646. nPageStep =i ;
  647. return 3 ;
  648. case 3: //只输入了三个字符,除了这三个字符都可以改变
  649. n =c1 ; //不能改变第一个字节
  650. n1 =CharToInt( lpcsInput[2] ) ; //不能改变第三位数
  651. for( i=0 ; i<10 ; i++ )
  652. {
  653. lpsOutput[i*4] =i+'0' ;
  654. //返回这个编码
  655. lpsOutput[i*4+1] =c1 ;
  656. lpsOutput[i*4+2] =c2 ;
  657. if( i<9 )
  658. lpsOutput[i*4+3] =' ' ;
  660. //得到下一个编码
  661. if( !GetNextCode() ) //已经没有下一个编码了
  662. {
  663. *lpnLenOfOutput =(i+1)*4-1 ;
  664. nPages++ ;
  665. nPageStep =i+1 ;
  666. return 2 ; //只可以向前翻页  
  667. }
  668. //判断下一个编码是否合法
  669. if( c1 != n || (c2/16!=n1) ) //不合法
  670. {
  671. *lpnLenOfOutput =(i+1)*4-1 ;
  672. nPages++ ;
  673. nPageStep =i+1 ;
  674. return 2 ; //只可以向前翻页  
  675. }
  676. }
  677. *lpnLenOfOutput =i*4-1 ;
  678. nPages++ ;
  679. nPageStep =i ;
  680. return 3 ;
  681. }
  683. return 0 ;
  684. }
  686. //判断内码是否合法
  687. BOOL JudgeCode( LPCSTR lpcsInput , int nLenOfInput )
  688. {
  689. switch( GetInputCode() ) //判断当前的输入内码
  690. {
  691. case 0: //GB
  692. case 2: //HZ
  693. return JudgeGBCode( lpcsInput , nLenOfInput ) ;
  694. case 1: //BIG5
  695. return JudgeBig5Code( lpcsInput , nLenOfInput ) ;
  696. case 3: //SHIFT-JIS
  697. return JudgeShiftJisCode( lpcsInput , nLenOfInput ) ;
  698. case 4: //EUC-JIS
  699. return JudgeEucJisCode( lpcsInput , nLenOfInput ) ;
  700. case 5: //KSC5601
  701. return JudgeKsc5601Code( lpcsInput , nLenOfInput ) ;
  702. }
  704. return 0 ;
  705. }
  707. //根据c1,c2,得到下一个代码,c1,c2必须正确
  708. BOOL GetNextCode( void )
  709. {
  710. switch( GetInputCode() ) //判断当前的输入内码
  711. {
  712. case 0: //GB
  713. case 2: //HZ
  714. return GetNextGBCode() ;
  715. case 1: //BIG5
  716. return GetNextBig5Code() ;
  717. case 3: //SHIFT-JIS
  718. return GetNextShiftJisCode() ;
  719. case 4: //EUC-JIS
  720. return GetNextEucJisCode() ;
  721. case 5: //KSC5601
  722. return GetNextKsc5601Code() ;
  723. }
  725. return 0 ;
  726. }
  728. //根据c1,c2,得到前一个代码
  729. BOOL GetPriorCode( void )
  730. {
  731. switch( GetInputCode() ) //判断当前的输入内码
  732. {
  733. case 0: //GB
  734. case 2: //HZ              
  735. return GetPriorGBCode() ;
  736. case 1: //BIG5
  737. return GetPriorBig5Code() ;
  738. case 3: //SHIFT-JIS
  739. return GetPriorShiftJisCode() ;
  740. case 4: //EUC-JIS
  741. return GetPriorEucJisCode() ;
  742. case 5: //KSC5601
  743. return GetPriorKsc5601Code() ;
  744. }
  746. return 0 ;
  747. }
  749. //初始c1,c2
  750. void InitC1C2( LPCSTR lpcsInput , int nLenOfInput )
  751. {
  752. switch( GetInputCode() ) //判断当前的输入内码
  753. {
  754. case 0: //GB
  755. case 2: //HZ
  756. InitGBC1C2( lpcsInput , nLenOfInput ) ;
  757. return ;
  758. case 1: //BIG5
  759. InitBig5C1C2( lpcsInput , nLenOfInput ) ;
  760. return ;
  761. case 3: //SHIFT-JIS
  762. InitShiftJisC1C2( lpcsInput , nLenOfInput ) ;
  763. return ;
  764. case 4: //EUC-JIS
  765. InitEucJisC1C2( lpcsInput , nLenOfInput ) ;
  766. return ;
  767. case 5: //KSC5601
  768. InitKsc5601C1C2( lpcsInput , nLenOfInput ) ;
  769. return ;
  770. }
  771. }
  773. //--------------------------------------------------------------------------------------------------------//
  774. #ifdef __cplusplus
  775. extern "C" {
  776. #endif
  778. //根据输入的英文内码,得到汉字
  779. //nFlag=0,从头开始查,设置翻页指针
  780. //nFlag=3,向下翻页,改变翻页指针
  781. //nFlag=4,向上翻页
  782. //返回0:出错或者输入字符不合法
  783. //返回1:只可以向下翻页
  784. //返回2:只可以向上翻页
  785. //返回3:可以向下也可以向上翻页
  786. //返回4:不能进行翻页
  787. int __export FAR PASCAL GetHzOfCode(
  788. LPCSTR lpcsInput , int nLenOfInput , //输入串和长度
  789. LPSTR lpsOutput , LPINT lpnLenOfOutput , //输出串和长度
  790. int nFlag )
  791. {
  792. if( nFlag==3 ) //向下翻页
  793. return PageNext( lpcsInput , nLenOfInput , lpsOutput , lpnLenOfOutput ) ;
  794. if( nFlag==4 ) //向上翻页
  795. {
  796. for( int i=0 ; i<10+nPageStep ; i++ ) //往前翻两页
  797. GetPriorCode() ;
  798. nPages -=2 ; //减少两页
  799. //往下翻一页
  800. PageNext( lpcsInput , nLenOfInput , lpsOutput , lpnLenOfOutput ) ;
  801. if( !nPages ) //一页没翻
  802. return 1 ; //只可以向下翻页
  803. return 3 ; //可以向上也可以向下翻页
  804. }
  805.         
  806.         //剩余的就是从头开始查
  807. //判断输入内码是否合法
  808. if( !JudgeCode( lpcsInput , nLenOfInput ) ) //不合法
  809. return 0 ;
  811. if( nLenOfInput==4 ) //长度为4,直接返回
  812. {
  813. lpsOutput[0] ='1' ;
  814. lpsOutput[1] =CharToInt( lpcsInput[0] )*16 + CharToInt( lpcsInput[1] ) ;
  815. lpsOutput[2] =CharToInt( lpcsInput[2] )*16 + CharToInt( lpcsInput[3] ) ;
  816. *lpnLenOfOutput =3 ;
  817. return 1 ;
  818. }
  820. //确定初始的c1,c2
  821. InitC1C2( lpcsInput , nLenOfInput ) ;
  823. //赋值
  824. for( int i=0 ; i<10 ; i++ )
  825. {
  826. lpsOutput[i*4] =i+'0' ;
  827. lpsOutput[i*4+1] =c1 ;
  828. lpsOutput[i*4+2] =c2++ ;
  829. if( i<9 )
  830. lpsOutput[i*4+3] =' ' ;
  831. }
  832. *lpnLenOfOutput =39 ;
  834. nPages =0 ; //初始翻过的页
  835.         return 1 ;
  836. }
  838. #ifdef __cplusplus
  839. }
  840. #endif