home *** CD-ROM | disk | FTP | other *** search
/ Media Share 9 / MEDIASHARE_09.ISO / progmisc / djasy10d.zip / DIFFS.10D < prev    next >
Text File  |  1992-09-11  |  10KB  |  413 lines
  1. diff -bBd async.100/async.c async/async.c
  2. 0a1,4
  3. > /*  async.c -- dj's async interface, modified for two ports and
  4. >     pointer-bashing protection by j. alan eldridge 09/04/92
  5. > */
  6. > 
  7. 1a6
  8. > #include <stdlib.h>
  9. 3a9,10
  10. > #include "djasync.h"
  11. > 
  12. 10a18,23
  13. > #define disable() asm("cli")
  14. > #define enable() asm("sti")
  15. > #endif
  16. > 
  17. > #ifdef __TURBOC__
  18. > #include <conio.h>
  19. 12a26,28
  20. > #define NO_INTR 1
  21. > #define RDY_CNT 1
  22. > 
  23. 21a38,41
  24. >   short count;
  25. >   short overflow;
  26. >   short buffer_size;
  27. >   short ovflushes;
  28. 24,33c44,45
  29. < static ASYNC_STRUCT far *async;
  30. < static int iov;
  31. < #define com_rb    iov
  32. < #define com_tb    iov
  33. < #define com_ier    iov+1
  34. < #define com_ifr    iov+2
  35. < #define com_bfr    iov+3
  36. < #define com_mcr    iov+4
  37. < #define com_lsr    iov+5
  38. < #define com_msr    iov+6
  39. ---
  40. > static ASYNC_STRUCT far *async[2];
  41. > static int              iov[2];
  42. 35c47,56
  43. < char far *aptr(short p)
  44. ---
  45. > #define com_rb(n)    iov[n]
  46. > #define com_tb(n)    iov[n]
  47. > #define com_ier(n)    iov[n]+1
  48. > #define com_ifr(n)    iov[n]+2
  49. > #define com_bfr(n)    iov[n]+3
  50. > #define com_mcr(n)    iov[n]+4
  51. > #define com_lsr(n)    iov[n]+5
  52. > #define com_msr(n)    iov[n]+6
  53. > 
  54. > static char far *aptr(int port, short p)
  55. 38c59
  56. <   return (char *)((unsigned)async - OFFSET + p);
  57. ---
  58. >   return (char *)((unsigned)async[port] - OFFSET + p);
  59. 40c61
  60. <   return (char far *)MK_FP(FP_SEG(async), p);
  61. ---
  62. >   return (char far *)MK_FP(FP_SEG(async[port]), p);
  63. 44c65
  64. < ASYNC_STRUCT far *getivec(int which)
  65. ---
  66. > static ASYNC_STRUCT far *getivec(int which)
  67. 61c82
  68. < async_init()
  69. ---
  70. > int async_init(int port)
  71. 63,79c84,86
  72. <   ASYNC_STRUCT far *a1;
  73. <   ASYNC_STRUCT far *a2;
  74. <   a1 = getivec(12);
  75. <   a2 = getivec(11);
  76. <   async = 0;
  77. <   if (a1)
  78. <     async = a1;
  79. <   if (a2)
  80. <     async = a2;
  81. <   if (a1 && a2)
  82. <   {
  83. <     if (a1 < a2)
  84. <       async = a1;
  85. <     else
  86. <       async = a2;
  87. <   }
  88. <   if (async == 0)
  89. ---
  90. >   async[port] = getivec(12-port);
  91. > 
  92. >   if (!async[port])
  93. 82c89
  94. <     exit(1);
  95. ---
  96. >     return 0;
  97. 84,87c91,95
  98. <   iov = async->iov;
  99. <   outportb(com_ier, 0x0f);
  100. <   outportb(com_bfr, 0x03);
  101. <   outportb(com_mcr, 0x0b);
  102. ---
  103. >   iov[port] = async[port]->iov;
  104. >   outportb(com_ier(port), 0x0f);
  105. >   outportb(com_bfr(port), 0x03);
  106. >   outportb(com_mcr(port), 0x0b);
  107. >   return 1;
  108. 90c98
  109. < async_tx(char c)
  110. ---
  111. > int async_cnt(int port)
  112. 92,93c100
  113. <   while (~inportb(com_lsr) & 0x20);
  114. <   outportb(com_tb, c);
  115. ---
  116. >     return async[port]->count;
  117. 96c103
  118. < int async_ready()
  119. ---
  120. > void async_flush(int port)
  121. 98c105,108
  122. <   return (async->getp != async->putp);
  123. ---
  124. >     disable();
  125. >     async[port]->count = async[port]->overflow = 0;
  126. >     async[port]->getp = async[port]->putp = async[port]->buffer_start;
  127. >     enable();
  128. 101c111,147
  129. < int async_rx()
  130. ---
  131. > int async_overflow(int port)
  132. > {
  133. >     int ret;
  134. >     
  135. >     disable();
  136. >     ret = async[port]->overflow;
  137. >     async[port]->overflow = 0;
  138. >     enable();
  139. > 
  140. >     return ret;
  141. > }
  142. > 
  143. > 
  144. > int async_tx(int port, char c)
  145. > {
  146. >   while (~inportb(com_lsr(port)) & 0x20);
  147. >   outportb(com_tb(port), c);
  148. > 
  149. >   return 0;
  150. > }
  151. > 
  152. > int async_ready(int port)
  153. > {
  154. >   int ret;
  155. >   
  156. >   disable();
  157. > #if RDY_CNT
  158. >   ret = async[port]->count;
  159. > #else
  160. >   ret = (async[port]->getp != async[port]->putp);
  161. > #endif
  162. >   enable();
  163. > 
  164. >   return ret;
  165. > }
  166. > 
  167. > int async_rx(int port)
  168. 104,107c150,160
  169. <   while (!async_ready);
  170. <   rv = *aptr(async->getp++);
  171. <   if (async->getp >= async->buffer_end)
  172. <     async->getp = async->buffer_start;
  173. ---
  174. > 
  175. >   while (!async_ready(port))
  176. >       /* spin wheels */;
  177. > 
  178. >   disable();
  179. >   rv = *aptr(port, async[port]->getp++);
  180. >   async[port]->count--;
  181. >   if (async[port]->getp >= async[port]->buffer_end)
  182. >     async[port]->getp = async[port]->buffer_start;
  183. >   enable();
  184. > 
  185. diff -bBd async.100/asynctsr.asm async/asynctsr.asm
  186. 4a5,6
  187. > BUFSIZE            = 4096
  188. > 
  189. 13c15
  190. < buffer_end    equ    buffer_start+500
  191. ---
  192. > buffer_end      equ     buffer_start+BUFSIZE
  193. 20,21c22,23
  194. <     dw    offset buffer_start
  195. <     dw    offset buffer_end
  196. ---
  197. > bbeg    dw      offset buffer_start
  198. > bend    dw      offset buffer_start
  199. 24a27,30
  200. > count   dw      0
  201. > over    dw      0
  202. > bsize   dw      BUFSIZE
  203. > flush   dw      1
  204. 60,64c66,90
  205. <     mov    cs:[bx],al
  206. <     inc    bx
  207. <     cmp    bx,offset buffer_end
  208. <     jb    isr_noend
  209. <     mov    bx,offset buffer_start
  210. ---
  211. >         mov     cx,count
  212. >         ; check for & handle buffer overflow <jae>
  213. >         cmp     cx,bsize
  214. >         jb      isr_addch       ; count < bsize ==> ok
  215. >         inc     over            ; count the overflow
  216. > isr_ckflush:
  217. >         cmp     flush,0
  218. >         jg      isr_flush
  219. >         dec     cx              ; dec count (in cx) 
  220. >         dec     bx              ; back up putp (in bx)
  221. >         cmp     bx,offset buffer_start  ; fell off start of buffer?
  222. >         jge     isr_addch               ; no, go ahead
  223. >         mov     bx,bend                 ; yes, wrap to end of buffer - 1
  224. >         dec     bx
  225. >         jmp     isr_addch
  226. > isr_flush:
  227. >     xor    cx, cx
  228. >         ; end of overflow handling <jae>
  229. > isr_addch:
  230. >         inc     cx              ; count new char
  231. >         mov     cs:[bx],al      ; save it at putp
  232. >         inc     bx              ; inc putp
  233. >         cmp     bx,bend         ; fell off end of buffer?
  234. >         jb      isr_noend       ; no, go ahead
  235. >         mov     bx,offset buffer_start  ; yes, wrap to start of buffer
  236. 66c92,93
  237. <     mov    putp,bx
  238. ---
  239. >         mov     putp,bx         ; save off new putp
  240. >         mov     count,cx        ; save off new count
  241. 76a104,108
  242. > err1    db      'Usage: asynctsr 1|2 [-][nnnn]',13,10
  243. >         db      '    -      no-flush-on-overflow flag (opt)',13,10
  244. >         db      '    nnnn   receive buffer size (opt,default=4096)'
  245. >         db      13,10,'$'
  246. > 
  247. 82a115
  248. > cmderr:
  249. 89,90d121
  250. < err1    db    'Usage: asynctsr 1|2',13,10,'$'
  251. < 
  252. 91a123
  253. >         call    parse
  254. 97a130
  255. >         call    parse
  256. 104a138
  257. >         cli
  258. 106a141
  259. >         sti
  260. 123c158,160
  261. <     mov    dx,offset buffer_end
  262. ---
  263. >         mov     dx,offset buffer_start
  264. >         add     dx,[bsize]
  265. >         mov     [bend], dx
  266. 127a165,208
  267. > parse:  ; parse the buffer size from the command line
  268. >         mov     cl, ds:[80h];
  269. >         cmp     cl, 3
  270. >         jl      endparse
  271. >         mov     si, 83h
  272. >         lodsb   
  273. >         cmp     al,' '
  274. >         jne     errparse
  275. >         mov     al,[si]
  276. >         cmp     al,'-'
  277. >         jne     goparse
  278. >         mov     flush,0
  279. >         dec     cl
  280. >         inc     si
  281. > goparse:
  282. >         sub     cl, 3
  283. >         je      endparse
  284. >         xor     dx, dx
  285. >         xor     bh, bh
  286. >         xor     ax, ax
  287. >         mov     di, 10
  288. > get1:
  289. >         mov     bl,ds:[si]
  290. >         inc     si
  291. >         dec     cl
  292. >         cmp     bl,'0'
  293. >         jl      errparse
  294. >         cmp     bl,'9'
  295. >         jg      errparse
  296. >         sub     bl,'0'
  297. >         imul    di
  298. >         add     ax,bx
  299. >         cmp     cl, 0
  300. >         jg      get1
  301. > setsize:        
  302. >         or      ax,ax
  303. >         je      endparse
  304. >         mov     bsize,ax
  305. > endparse:
  306. >         ret
  307. > 
  308. > errparse:
  309. >         jmp     cmderr
  310. > 
  311. Binary files async.100/asynctsr.com and async/asynctsr.com differ
  312. diff -bBd async.100/atest.c async/atest.c
  313. 1a2
  314. > #include <stdlib.h>
  315. 2a4,6
  316. > #include <io.h>
  317. > 
  318. > #include "djasync.h"
  319. 5c9,11
  320. < #define getch getkey
  321. ---
  322. > #include    <gppconio.h>
  323. > #else
  324. > #include    <conio.h>
  325. 8c14,16
  326. < main()
  327. ---
  328. > #include    <dos.h>
  329. > 
  330. > main(int ac, char** av)
  331. 10c18,24
  332. <   async_init();
  333. ---
  334. >   int port = ac > 1 ? atoi(av[1]) - 1 : 0;
  335. >   int show = ac > 2;
  336. >   int msec = ac > 2 ? atoi(av[2]) : 0;
  337. >     
  338. >   if (!async_init(port))
  339. >       return 1;
  340. > 
  341. 12a27,28
  342. >     int x,y;
  343. > 
  344. 18c34
  345. <       async_tx(ch);
  346. ---
  347. >       async_tx(port,ch);
  348. 20c36,47
  349. <     if (async_ready())
  350. ---
  351. > 
  352. >     if (show) {
  353. >         if (msec)
  354. >             delay(msec);
  355. >         x=wherex();
  356. >         y=wherey();
  357. >         gotoxy(1,1);
  358. >         cprintf("%04d %04d",async_cnt(port),async_overflow(port));
  359. >         gotoxy(x,y);
  360. >     }
  361. >         
  362. >     if (async_ready(port))
  363. 22c49
  364. <       char c = async_rx();
  365. ---
  366. >       char c = async_rx(port);
  367. 25a53
  368. >   return 0;
  369. Binary files async.100/atest.exe and async/atest.exe differ
  370. Only in async: atestpp.cc
  371. Only in async: atestpp.exe
  372. Only in async: diffs.10c
  373. Only in async: djasync.h
  374. Binary files async.100/gtest and async/gtest differ
  375. Only in async: gtestpp
  376. diff -bBd async.100/makefile async/makefile
  377. 1c1,5
  378. < all : asynctsr.com atest.exe gtest
  379. ---
  380. > all: asynctsr.com atest.exe gtest atestpp.exe gtestpp
  381. > 
  382. > # if you have Turbo C++, use tcc instead
  383. > CC=bcc -v -c-
  384. > GCC=gcc -g -O2
  385. 4,6c8,9
  386. <     masm asynctsr;
  387. <     tlink asynctsr;
  388. <     exe2bin asynctsr.exe asynctsr.com
  389. ---
  390. >     tasm asynctsr;
  391. >     tlink /t asynctsr;
  392. 8,9c11,12
  393. < atest.exe : atest.obj async.obj
  394. <     tcc atest.obj async.obj
  395. ---
  396. > atest.exe : atest.c async.c
  397. >     $(CC) atest.c async.c
  398. 11,12c14,23
  399. < gtest : atest.o async.o
  400. <     gcc -o gtest atest.o async.o -lpc
  401. ---
  402. > gtest : atest.c async.c
  403. >     $(GCC) -o gtest atest.c async.c -lpc
  404. > 
  405. > atestpp.exe : atestpp.cc async.c
  406. >         copy atestpp.cc atestpp.cpp
  407. >     $(CC) atestpp.cpp async.c
  408. >         del atestpp.cpp
  409. > 
  410. > gtestpp : atestpp.cc async.c
  411. >     $(GCC) -o gtestpp atestpp.cc async.c -lpc
  412. Only in async: readme.jae
  413.