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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 操作系统开发 > 查看源码
CHARIO.C
资源名称：840.rar　[点击查看]
上传用户：dcs7469208
上传日期：2010-01-02
资源大小：443k
文件大小：9k
源码类别：

操作系统开发

开发平台：

DOS

CHARIO.C：源码内容
  2. /****************************************************************/
  3. /*                                                              */
  4. /*                          chario.c                            */
  5. /*                           DOS-C                              */
  6. /*                                                              */
  7. /*    Character device functions and device driver interface    */
  8. /*                                                              */
  9. /*                      Copyright (c) 1994                      */
  10. /*                      Pasquale J. Villani                     */
  11. /*                      All Rights Reserved                     */
  12. /*                                                              */
  13. /* This file is part of DOS-C.                                  */
  14. /*                                                              */
  15. /* DOS-C is free software; you can redistribute it and/or       */
  16. /* modify it under the terms of the GNU General Public License  */
  17. /* as published by the Free Software Foundation; either version */
  18. /* 2, or (at your option) any later version.                    */
  19. /*                                                              */
  20. /* DOS-C is distributed in the hope that it will be useful, but */
  21. /* WITHOUT ANY WARRANTY; without even the implied warranty of   */
  22. /* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See    */
  23. /* the GNU General Public License for more details.             */
  24. /*                                                              */
  25. /* You should have received a copy of the GNU General Public    */
  26. /* License along with DOS-C; see the file COPYING.  If not,     */
  27. /* write to the Free Software Foundation, 675 Mass Ave,         */
  28. /* Cambridge, MA 02139, USA.                                    */
  29. /*                                                              */
  30. /****************************************************************/
  32. #include "../../hdr/portab.h"
  34. /* $Logfile:   C:/dos-c/src/fs/chario.c_v  $ */
  35. #ifdef VERSION_STRINGS
  36. static BYTE *charioRcsId = "$Header:   C:/dos-c/src/fs/chario.c_v   1.8   11 Jan 1998  2:06:08   patv  $";
  37. #endif
  39. /* $Log:   C:/dos-c/src/fs/chario.c_v  $
  40.  * 
  41.  *    Rev 1.8   11 Jan 1998  2:06:08   patv
  42.  * Added functionality to ioctl.
  43.  * 
  44.  *    Rev 1.7   08 Jan 1998 21:36:40   patv
  45.  * Changed automatic requestic packets to static to save stack space.
  46.  * 
  47.  *    Rev 1.6   04 Jan 1998 23:14:38   patv
  48.  * Changed Log for strip utility
  49.  * 
  50.  *    Rev 1.5   30 Dec 1997  4:00:20   patv
  51.  * Modified to support SDA
  52.  * 
  53.  *    Rev 1.4   16 Jan 1997 12:46:36   patv
  54.  * pre-Release 0.92 feature additions
  55.  * 
  56.  *    Rev 1.3   29 May 1996 21:15:12   patv
  57.  * bug fixes for v0.91a
  58.  * 
  59.  *    Rev 1.2   01 Sep 1995 17:48:42   patv
  60.  * First GPL release.
  61.  * 
  62.  *    Rev 1.1   30 Jul 1995 20:50:26   patv
  63.  * Eliminated version strings in ipl
  64.  * 
  65.  *    Rev 1.0   02 Jul 1995  8:05:44   patv
  66.  * Initial revision.
  67.  *
  68.  */ 
  69. /* $EndLog$ */
  71. #include "globals.h"
  73. static BYTE *con_name = "CON";
  75. #if !defined(KERNEL) && !defined(IPL)
  76. VOID INRPT FAR 
  77. handle_break (void)
  78. {
  79. }
  80. #endif
  82. #ifdef PROTO
  83. BOOL _sto(COUNT);
  84. VOID kbfill(keyboard FAR *, UCOUNT, BOOL);
  85. struct dhdr FAR *finddev(UWORD attr_mask);
  87. #else
  88. BOOL _sto();
  89. VOID kbfill();
  90. struct dhdr FAR *finddev();
  91. #endif
  93. /*      Return a pointer to the first driver in the chain that 
  94.  *      matches the attributes. 
  95.  */
  97. struct dhdr FAR *finddev(UWORD attr_mask)
  98. {
  99. struct dhdr far *dh;
  101. for (dh = nul_dev.dh_next; FP_OFF(dh) != 0xFFFF; dh = dh -> dh_next)
  102. {
  103.      if (dh -> dh_attr & attr_mask)
  104.  return dh;
  105. }
  107. /* return dev/null if no matching driver found */
  108. return &nul_dev;
  109. }
  112. BYTE *CharName(struct dhdr far *lpDhdr)
  113. {
  114. struct dhdr far *dh;
  115. static BYTE szName[9];
  116. COUNT nIdx;
  118. /* Scan through the device list */
  119. for (dh = nul_dev.dh_next; FP_OFF(dh) != 0xFFFF; dh = dh -> dh_next)
  120. {
  121. if (dh == lpDhdr)
  122. break;
  123. }
  125. /* return name of /dev/null if no matching driver found */
  126. if(FP_OFF(dh) == 0xFFFF)
  127. dh = (struct dhdr far *)&nul_dev;
  129. /* Now convert it to a C string */
  130. for(nIdx = 0; nIdx < 8 && dh -> dh_name[nIdx] != ' '; nIdx++)
  131. szName[nIdx] = dh -> dh_name[nIdx];
  132. szName[nIdx] = '';
  133. return szName;
  134. }
  136. static BOOL 
  137. _sto (COUNT c)
  138. {
  139. BYTE buf = c;
  141. if(con_break())
  142. {
  143. handle_break();
  144. return FALSE;
  145. }
  146. CharReqHdr.r_length = sizeof(request);
  147. CharReqHdr.r_command = C_OUTPUT;
  148. CharReqHdr.r_count = 1;
  149. CharReqHdr.r_trans = (BYTE FAR *)(&buf);
  150. CharReqHdr.r_status = 0;
  151. execrh((request FAR *)&CharReqHdr, (struct dhdr FAR *)finddev(ATTR_STDOUT));
  152. if(CharReqHdr.r_status & S_ERROR)
  153. return char_error(&CharReqHdr, con_name);
  154. return TRUE;
  155. }
  158. VOID 
  159. sto (COUNT c)
  160. {
  161. /* Test for hold char                                   */
  162. con_hold();
  164. /* Display a printable character                        */
  165. if(c != HT)
  166. _sto(c);
  167. if(c == CR)
  168. scr_pos = 0;
  169. else if(c == BS)
  170. {
  171. if(scr_pos > 0)
  172. --scr_pos;
  173. }
  174. else if(c == HT)
  175. {
  176. do
  177. _sto(' ');
  178. while(++scr_pos & 7);
  179. }
  180. else if(c != LF && c != BS)
  181. ++scr_pos;
  182. }
  185. VOID 
  186. mod_sto (REG UCOUNT c)
  187. {
  188. if(c < ' ' && c != HT)
  189. {
  190. sto('^');
  191. sto(c + '@');
  192. }
  193. else
  194. sto(c);
  195. }
  198. VOID 
  199. destr_bs (void)
  200. {
  201. sto(BS);
  202. sto(' ');
  203. sto(BS);
  204. }
  207. UCOUNT 
  208. _sti (void)
  209. {
  210. UBYTE cb;
  212. CharReqHdr.r_length = sizeof(request);
  213. CharReqHdr.r_command = C_INPUT;
  214. CharReqHdr.r_count = 1;
  215. CharReqHdr.r_trans = (BYTE FAR *)&cb;
  216. CharReqHdr.r_status = 0;
  217. execrh((request FAR *)&CharReqHdr, (struct dhdr FAR *)finddev(ATTR_STDIN));
  218. if(CharReqHdr.r_status & S_ERROR)
  219. return char_error(&CharReqHdr, con_name);
  220. if(cb == CTL_C)
  221. {
  222. handle_break();
  223. return CTL_C;
  224. }
  225. else
  226. return cb;
  227. }
  229. VOID 
  230. con_hold (void)
  231. {
  232. CharReqHdr.r_unit = 0;
  233. CharReqHdr.r_status = 0;
  234. CharReqHdr.r_command = C_NDREAD;
  235. CharReqHdr.r_length = sizeof(request);
  236. execrh((request FAR *)&CharReqHdr, (struct dhdr FAR *)finddev(ATTR_STDIN));
  237. if(CharReqHdr.r_status & S_BUSY)
  238. return;
  239. if(CharReqHdr.r_ndbyte == CTL_S)
  240. {
  241. _sti();
  242. while(_sti() != CTL_Q)
  243. /* just wait */;
  244. }
  245. }
  248. BOOL 
  249. con_break (void)
  250. {
  251. CharReqHdr.r_unit = 0;
  252. CharReqHdr.r_status = 0;
  253. CharReqHdr.r_command = C_NDREAD;
  254. CharReqHdr.r_length = sizeof(request);
  255. execrh((request FAR *)&CharReqHdr, (struct dhdr FAR *)finddev(ATTR_STDIN));
  256. if(CharReqHdr.r_status & S_BUSY)
  257. return FALSE;
  258. if(CharReqHdr.r_ndbyte == CTL_C)
  259. {
  260. _sti();
  261. return TRUE;
  262. }
  263. else
  264. return FALSE;
  265. }
  268. BOOL 
  269. KbdBusy (void)
  270. {
  271. CharReqHdr.r_unit = 0;
  272. CharReqHdr.r_status = 0;
  273. CharReqHdr.r_command = C_ISTAT;
  274. CharReqHdr.r_length = sizeof(request);
  275. execrh((request FAR *)&CharReqHdr, (struct dhdr FAR *)finddev(ATTR_STDIN));
  276. if(CharReqHdr.r_status & S_BUSY)
  277. return TRUE;
  278. else
  279. return FALSE;
  280. }
  282. VOID 
  283. KbdFlush (void)
  284. {
  285. CharReqHdr.r_unit = 0;
  286. CharReqHdr.r_status = 0;
  287. CharReqHdr.r_command = C_IFLUSH;
  288. CharReqHdr.r_length = sizeof(request);
  289. execrh((request FAR *)&CharReqHdr, (struct dhdr FAR *)finddev(ATTR_STDIN));
  290. }
  293. static VOID kbfill(kp, c, ctlf)
  294. keyboard FAR *kp;
  295. UCOUNT c;
  296. BOOL ctlf;
  297. {
  298. if(kp -> kb_count > kp -> kb_size)
  299. {
  300. sto(BELL);
  301. return;
  302. }
  303. kp -> kb_buf[kp -> kb_count++] = c;
  304. if(!ctlf)
  305. mod_sto(c);
  306. else
  307. sto(c);
  308. }
  311. VOID sti(kp)
  312. keyboard FAR *kp;
  313. {
  314. REG UWORD c, cu_pos = scr_pos;
  315. WORD init_count = kp -> kb_count;
  316. #ifndef NOSPCL
  317. static BYTE local_buffer[LINESIZE];
  318. #endif
  320. if(kp -> kb_size == 0)
  321. return;
  322. if(kp -> kb_size <= kp -> kb_count || kp -> kb_buf[kp -> kb_count] != CR)
  323. kp -> kb_count = 0;
  324. FOREVER
  325. {
  326. switch(c = _sti())
  327. {
  328. case CTL_F:
  329. continue;
  331. #ifndef NOSPCL
  332. case SPCL:
  333. switch(c = _sti())
  334. {
  335. case LEFT:
  336. goto backspace;
  338. case F3:
  339. {
  340. REG COUNT i;
  342. for(i = kp -> kb_count; local_buffer[i] != ''; i++)
  343. {
  344. c = local_buffer[kp -> kb_count];
  345. if(c == 'r' || c == 'n')
  346. break;
  347. kbfill(kp, c, FALSE);
  348. }
  349. break;
  350. }
  352. case RIGHT:
  353. c = local_buffer[kp -> kb_count];
  354. if(c == 'r' || c == 'n')
  355. break;
  356. kbfill(kp, c, FALSE);
  357. break;
  358. }
  359. break;
  360. #endif
  362. case CTL_BS:
  363. case BS:
  364. backspace:
  365. if(kp -> kb_count > 0)
  366. {
  367. if(kp -> kb_buf[kp -> kb_count - 1] >= ' ')
  368. {
  369. destr_bs();
  370. }
  371. else if((kp -> kb_buf[kp -> kb_count - 1] < ' ')
  372.  && (kp -> kb_buf[kp -> kb_count - 1] != HT))
  373. {
  374. destr_bs();
  375. destr_bs();
  376. }
  377. else if(kp -> kb_buf[kp -> kb_count - 1] == HT)
  378. {
  379. do
  380. {
  381. destr_bs();
  382. }
  383. while((scr_pos > cu_pos) && (scr_pos & 7));
  384. }
  385. --kp -> kb_count;
  386. }
  387. break;
  389. case CR:
  390. kbfill(kp, CR, TRUE);
  391. kbfill(kp, LF, TRUE);
  392. #ifndef NOSPCL
  393. fbcopy((BYTE FAR *)kp -> kb_buf,
  394.  (BYTE FAR *)local_buffer, (COUNT)kp -> kb_count);
  395. local_buffer[kp -> kb_count] = '';
  396. #endif
  397. return;
  399. case LF:
  400. sto(CR);
  401. sto(LF);
  402. break;
  404. case ESC:
  405. sto('\');
  406. sto(CR);
  407. sto(LF);
  408. for(c = 0; c < cu_pos; c++)
  409. sto(' ');
  410. kp -> kb_count = init_count;
  411. break;
  413. default:
  414. kbfill(kp, c, FALSE);
  415. break;
  416. }
  417. }
  418. }