home *** CD-ROM | disk | FTP | other *** search
/ Columbia Kermit / kermit.zip / dgrdos2 / rd2ker.bas next >
BASIC Source File  |  2020-01-01  |  20KB  |  588 lines
  1. 0010 REM *****************************************************
  2. 0020 REM *                                                   *
  3. 0030 REM *               KERMIT RDOS                         *
  4. 0040 REM *             ===================                   *
  5. 0050 REM *                                                   *
  6. 0060 REM *  KERMIT PROTOCOL MANUAL CLOSELY EXEPT FOR USER    *
  7. 0070 REM *  INTERACTION, WHICH USES A MORE INTERACTIVE       *
  8. 0080 REM *  DIALOGUE .                                       *
  9. 0090 REM *  THIS VERSION IS A MODIFICATION FOR RDOS OF THE   *
  10. 0100 REM *  VERSION OF TORBJORN ALM & PER LINDBERG FOR THE   *
  11. 0110 REM *  ABC-800.                                         *
  12. 0120 REM *                                                   *
  13. 0130 REM *  MODIFIER LE 06/12/85    REMI CASTONGUAY          *
  14. 0140 REM *                                                   *
  15. 0150 REM *  MODIFIER LEGEREMENT POUR L'ECLIPSE               *
  16. 0160 REM *****************************************************
  17. 0170 REM
  18. 0180 DIM RECPKT$[80],PACKET$[80],INBUFF$[512],SP$[25],B$[90],QUO$[1],H$[1]
  19. 0190 DIM DUMMY$[1],FILE$[60],S$[80],F$[1],AA$[60],FNQ$[10]
  20. 0200 DIM SPAR$[100],INCHR$[90],TYPE$[100],X$[1],MESSAG$[90],REPLY$[90]
  21. 0210 DIM BUFFER$[90],DATAX$[80],DATA$[80],DEBUG$[3]
  22. 0220 DIM H1$[1],H2$[2],H3$[3],H4$[4],CONTRO$[32]
  23. 0230 LET MAXPCK=78 \ SOH=1 \ MAXTRY=500 \ MYPAD=0 \ MYCHAR=0 \ MYEOL=13
  24. 0240 LET MYTIME=5 \ MAXTIM=20 \ MINTIM=2 \ TRUE=-1 \ FALSE=0
  25. 0250 LET SP=32 \ DEL=127 \ EOL=13 \ OK=0 \ BLOC=0 \ CTES=0
  26. 0260 LET SP$=FILL$(32) \ QUO$="#" \ MYQUOT=ASC(QUO$)
  27. 0270 LET PORT=2 \ RET%=3 \ ER=0 \ TIMINT=5 \ ETC=38 \ FIN=0
  28. 0272 LET LREC=0
  29. 0280 FOR I=0 TO 31
  30. 0290   LET CONTRO$[0]=CHR$(I,1)
  31. 0300 NEXT I
  32. 0310 CLOSE
  33. 0320 STMA 7,0
  34. 0330 LET DEBUG=0 \ DEBUG$="OFF" \ ENV%=PORT
  35. 0340 PRINT @(-30)
  36. 0350 GOSUB 5180 : PRINT MENU - INPUT COMMAND
  37. 0360 ON F THEN GOTO 4800, 0410, 0490, 0570, 0620
  38. 0370 ON IKEY THEN GOTO 0250
  39. 0380 REM **************************
  40. 0390 REM  RECEIVE FILES FROM REMOTE
  41. 0400 REM **************************
  42. 0410 GOSUB 3500 : STATE TABLE SWITCHER FOR RECEIVE FILES
  43. 0420 IF STATE THEN PRINT @(19,1);"OK ";SP$ ELSE PRINT @(19,1);"RCEIV FAILED";SP$
  44. 0430 PRINT "<PUSH ANY KEY TO CONTINUE>"
  45. 0440 INPUT USING "","",@(-10,1),X$
  46. 0450 GOTO 0310
  47. 0460 REM **************************
  48. 0470 REM SEND FILE TO REMOTE
  49. 0480 REM **************************
  50. 0490 GOSUB 4940 : INPUT FILE NAMES - CHECK FILES
  51. 0500 IF NFILE<0 THEN GOTO 0310
  52. 0510 GOSUB 2100 : SEND SUPERVISOR
  53. 0520 IF STATE THEN PRINT @(19,1);"OK";SP$ ELSE PRINT @(19,1);"SEND FAILED";SP$
  54. 0530 PRINT "<PUSH ANY KEY TO CONTINUE>"
  55. 0540 INPUT USING "","",@(-10,1),X$
  56. 0550 GOTO 0310
  57. 0560 REM *************************
  58. 0570 REM END OF KERMIT SESSION
  59. 0580 REM *************************
  60. 0590 PRINT @(15,20);"END OF KERMIT SESSION"
  61. 0600 CLOSE
  62. 0610 END
  63. 0620 IF DEBUG THEN GOTO 0650
  64. 0630 LET DEBUG=1 \ DEBUG$="ON "
  65. 0640 GOTO 0350
  66. 0650 LET DEBUG=0 \ DEBUG$="OFF"
  67. 0660 GOTO 0350
  68. 0670 REM *******************************
  69. 0680 REM SEND MY PARAMETERS TO OTHER END
  70. 0690 REM *******************************
  71. 0700 LET SPAR$=CHR$(MAXPCK+32,1),CHR$(MYTIME+32,1),CHR$(MYPAD+32,1)
  72. 0702 LET SPAR$[0]=CHR$(OR(MYCHAR,64)),CHR$(MYEOL+32,1),CHR$(MYQUOT,1)
  73. 0705 LET SPAR$[0]="&","1"," "
  74. 0710 RETURN
  75. 0720 REM **************************
  76. 0730 REM UNPACK DATA FROM OTHER END
  77. 0740 REM **************************
  78. 0750 LET SPSIZ=MIN(ASC(S$[1,1])-32,80)
  79. 0760 LET TIMINT=ASC(S$[2,2])-32
  80. 0770 LET PAD=ASC(S$[3,3])-32
  81. 0780 LET PADCHR=ASC(S$[4,4])-32
  82. 0790 LET PADCHR=OR(PADCHR,64)
  83. 0800 LET EOL=ASC(S$[5,5])-32
  84. 0810 LET QUOTE=ASC(S$[6,6])-32
  85. 0820 RETURN
  86. 0830 REM ***********************
  87. 0840 REM UNPACK A PACKET TO FILE
  88. 0850 REM B$  = PACKET BUFFER
  89. 0860 REM ***********************
  90. 0870 LET B$=""
  91. 0880 FOR I=1 TO LEN(PACKET$)
  92. 0890   LET H$=PACKET$[I,I]
  93. 0900   LET K=POS("#&",H$,1)
  94. 0910   ON K THEN GOSUB 0960, 1030
  95. 0920   LET B$[0]=H$
  96. 0930 NEXT I
  97. 0940 WRITE FILE[2],B$[1,LEN(B$)]
  98. 0950 RETURN
  99. 0960 REM
  100. 0970 GOSUB 1220
  101. 0980 IF POS("&#",H$,1) THEN RETURN
  102. 0990 LET H=OR(ASC(H$),64)
  103. 1000 IF AND(ASC(H$),64) THEN LET H=H-64
  104. 1010 LET H$=CHR$(H)
  105. 1020 RETURN
  106. 1030 REM
  107. 1040 GOSUB 1220
  108. 1050 IF H$="#" THEN GOSUB 1080
  109. 1060 GOSUB 1140
  110. 1070 RETURN
  111. 1080 REM
  112. 1090 GOSUB 1220
  113. 1100 LET K=POS("&#",H$,1)
  114. 1110 ON K THEN GOTO 1140, 1140
  115. 1120 GOSUB 1170
  116. 1130 RETURN
  117. 1140 REM
  118. 1150 LET H$=CHR$(OR(ASC(H$),128))
  119. 1160 RETURN
  120. 1170 REM
  121. 1180 LET H=OR(ASC(H$),64)
  122. 1190 IF AND(ASC(H$),64) THEN LET H=H-64
  123. 1200 LET H$=CHR$(H)
  124. 1210 RETURN
  125. 1220 REM
  126. 1230 LET I=I+1 \ H$=PACKET$[I,I]
  127. 1240 RETURN
  128. 1250 REM **************************
  129. 1260 REM FILL BUFFER, RETURN SIZE
  130. 1270 REM **************************
  131. 1280 LET B$=""
  132. 1290 IF EOF(2) THEN GOTO 1440
  133. 1300 IF LEN(INBUFF$)=0 THEN IF LREC THEN GOTO 1501 ELSE GOSUB 1460
  134. 1310 IF EOF(2) THEN GOTO 1440
  135. 1320 LET H$=INBUFF$[1,1] \ H1$=""
  136. 1330 IF ASC(H$)>127 THEN GOSUB 5350 ELSE LET H2$=H$
  137. 1340 LET I=LEN(H2$) \ H$=H2$[I,I]
  138. 1350 IF POS("#&",H$,1) THEN GOSUB 5400 ELSE LET H3$=H2$
  139. 1360 LET I=LEN(H3$) \ H$=H3$[I,I]
  140. 1370 IF POS(CONTRO$,H$,1) THEN GOSUB 5450 ELSE LET H4$=H3$
  141. 1380 LET B$[0]=H4$
  142. 1390 IF LEN(INBUFF$)>=2 THEN LET INBUFF$=INBUFF$[2] ELSE LET INBUFF$=""
  143. 1400 IF LEN(B$)>=SPSIZ-8 THEN GOTO 1420
  144. 1410 GOTO 1290
  145. 1420 LET PACKET$=B$
  146. 1430 RETURN
  147. 1440 LET STATE=ASC("Z")
  148. 1450 RETURN
  149. 1460 BLOCK READ FILE[2,BLOC],INBUFF$
  150. 1470 LET BLOC=BLOC+1
  151. 1480 RETURN
  152. 1490 LET B$[0]=H$
  153. 1500 GOTO 1390
  154. 1501 REM
  155. 1502 IF TOBUFF=LAST THEN GOTO 1440
  156. 1504 LET TOBUFF=TOBUFF+1
  157. 1506 READ FILE[2],INBUFF$[1,LREC]
  158. 1508 GOTO 1310
  159. 1510 REM ***************************************
  160. 1520 REM SEND PACKET TO OTHER END - CALL BY NAME
  161. 1530 REM ***************************************
  162. 1540 STMA 8,4
  163. 1550 STMA 6,0
  164. 1560 STMA 6,1
  165. 1570 STMA 6,2
  166. 1580 LET BUFFER$=CHR$(SOH),CHR$(LENGTH+35),CHR$(NUM+32),CHR$(TYPE),DATA$
  167. 1590 LET CHKSUM=LENGTH+NUM+TYPE+67
  168. 1600 LET I=1
  169. 1610 IF I>LENGTH THEN GOTO 1650
  170. 1620 LET CHKSUM=CHKSUM+ASC(DATA$[I,I])
  171. 1630 LET I=I+1
  172. 1640 GOTO 1610
  173. 1650 LET CHKSUM=AND((CHKSUM+AND(CHKSUM,192)/64),63)
  174. 1660 LET BUFFER$=BUFFER$,CHR$(CHKSUM+32),CHR$(EOL),CHR$(10)
  175. 1670 LET MESSAG$=BUFFER$
  176. 1680 GOSUB 5540 : GET LA LIGNE AU COMPLET
  177. 1690 LET H$=CHR$(TYPE)
  178. 1700 PRINT @(15,1);"SEND PACKET ";COMP;"  ";H$;"  ";NUMTRY
  179. 1710 RETURN
  180. 1720 REM *******************************************************
  181. 1730 REM            RECEIVE PACKET, STORE LEN,NUM ET RETURN TYPE
  182. 1740 REM *******************************************************
  183. 1760 STMA 6,0
  184. 1770 STMA 6,1
  185. 1780 STMA 6,2
  186. 1790 IF TIMINT>MAXTIM THEN LET TIMINT=MYTIME
  187. 1800 IF TIMINT<MINTIM THEN LET TIMINT=MYTIME
  188. 1810 LET T=0 \ V=0
  189. 1820 IF T=SOH THEN GOTO 1850
  190. 1830 GOSUB 5120 : GET LINE CHAR ONE BY ONE
  191. 1840 IF T<>SOH THEN GOTO 2070
  192. 1850 GOSUB 5120 : GET LINE CHAR ONE BY ONE
  193. 1860 IF T<0 THEN GOTO 1850 ELSE IF T=SOH THEN GOTO 2020
  194. 1870 LET CHKSUM=T \ L=T-35 \ LENGTH=T
  195. 1875 IF L+5<>LEN(INCHR$) THEN GOTO 2070
  196. 1880 GOSUB 5120 : GET LINE CHAR ONE BY ONE
  197. 1890 IF T<0 THEN GOTO 1880 ELSE IF T=SOH THEN GOTO 2020
  198. 1900 LET CHKSUM=CHKSUM+T \ NUM=T-32
  199. 1910 GOSUB 5120 : GET LINE CHAR ONE BY ONE
  200. 1920 IF T<0 THEN GOTO 1910 ELSE IF T=SOH THEN GOTO 2020
  201. 1930 LET CHKSUM=CHKSUM+T \ TYPE=T \ DATAX$=""
  202. 1940 FOR I=1 TO L
  203. 1950   GOSUB 5120 : GET LINE CHAR ONE BY ONE
  204. 1960   IF T<0 THEN GOTO 1950 ELSE IF T=SOH THEN GOTO 2020
  205. 1970   LET CHKSUM=CHKSUM+T
  206. 1980   LET DATAX$[0]=CHR$(T,1)
  207. 1990 NEXT I
  208. 2000 GOSUB 5120 : GET LINE CHAR ONE BY ONE
  209. 2010 IF T<0 THEN GOTO 2000
  210. 2020 LET CHKSUM=AND((CHKSUM+AND(CHKSUM,192)/64),63)
  211. 2030 IF CHKSUM<>T-32 THEN GOTO 2070
  212. 2040 LET H$=CHR$(TYPE)
  213. 2050 PRINT @(15,40);"RECEIVE PACKET   ";COMP;" ";H$;"  ";NUMTRY
  214. 2060 RETURN
  215. 2070 LET TYPE=0
  216. 2080 RETURN
  217. 2090 REM ***************
  218. 2100 REM SEND SUPERVISOR
  219. 2110 REM ***************
  220. 2120 LET STATE=ASC("S") \ N=0 \ NUMTRY=0 \ COMP=0 \ TOBUFF=0
  221. 2130 IF DEBUG THEN GOSUB 2330
  222. 2140 LET H$=CHR$(STATE)
  223. 2150 LET K=POS("DFZSBCA",H$,1)+1
  224. 2160 ON K THEN GOTO 2170, 2190, 2210, 2230, 2250, 2270, 2290, 2310
  225. 2170 LET STATE=FALSE
  226. 2180 RETURN
  227. 2190 GOSUB 2820 : SEND DATA FILE
  228. 2200 GOTO 2140
  229. 2210 GOSUB 2580 : SEND FILE HEADER
  230. 2220 GOTO 2140
  231. 2230 GOSUB 3090 : SEND END-OF-FILE
  232. 2240 GOTO 2140
  233. 2250 GOSUB 2360 : SENAMETERS, GET OTHER SIDE'S BACK
  234. 2260 GOTO 2140
  235. 2270 GOSUB 3320 : SEND BREAK (EOT)
  236. 2280 GOTO 2140
  237. 2290 LET STATE=TRUE
  238. 2300 RETURN
  239. 2310 LET STATE=FALSE
  240. 2320 RETURN
  241. 2330 OPEN FILE[6,0],"LOG.LOG"
  242. 2340 RETURN
  243. 2350 REM *****************************************
  244. 2360 REM SENAMETERS, GET OTHER SIDE'S BACK
  245. 2370 REM *****************************************
  246. 2380 IF NUMTRY>MAXTRY THEN GOTO 2550
  247. 2390 LET NUMTRY=NUMTRY+1
  248. 2400 GOSUB 0680 : SEND MY PARAMETERS TO OTHER END
  249. 2410 LET PACKET$=SPAR$
  250. 2420 LET TYPE=ASC("S") \ NUM=N \ LENGTH=9 \ DATA$=PACKET$
  251. 2430 GOSUB 1520 : SEND PACKET TO OTHER END - CALL BY NAME
  252. 2440 GOSUB 1730 :            RECEIVE PACKET, STORE LEN,NUM ET RETURN TYPE
  253. 2450 LET RECPKT$=DATAX$
  254. 2460 IF TYPE<>ASC("Y") THEN IF TYPE<>ASC("S") THEN GOTO 2380
  255. 2470 IF N<>NUM THEN GOTO 2380
  256. 2480 LET S$=RECPKT$
  257. 2490 GOSUB 0730 : UNPACK DATA FROM OTHER END
  258. 2500 IF EOL=0 THEN LET EOL=13
  259. 2510 IF QUOTE=0 THEN LET QUOTE=ASC(QUO$)
  260. 2520 LET NUMTRY=0 \ N=AND((N+1),63) \ COMP=COMP+1
  261. 2530 LET STATE=ASC("F")
  262. 2540 RETURN
  263. 2550 LET STATE=ASC("A")
  264. 2560 RETURN
  265. 2570 REM ****************
  266. 2580 REM SEND FILE HEADER
  267. 2590 REM ****************
  268. 2600 IF OK=1 THEN GOSUB 5000
  269. 2610 PRINT @(11,40);"SENDING FILE: ";FILE$
  270. 2620 IF NUMTRY>MAXTRY THEN GOTO 2790
  271. 2630 LET NUMTRY=NUMTRY+1
  272. 2640 LET LENGTH=LEN(FILE$)
  273. 2650 LET TYPE=ASC("F") \ NUM=N \ DATA$=FILE$
  274. 2660 GOSUB 1520 : SEND PACKET TO OTHER END - CALL BY NAME
  275. 2670 GOSUB 1730 :            RECEIVE PACKET, STORE LEN,NUM ET RETURN TYPE
  276. 2680 LET RECPKT$=DATAX$
  277. 2690 LET H$=CHR$(TYPE)
  278. 2700 LET K=POS("NY",H$,1)+1
  279. 2710 ON K THEN GOTO 2650, 2650, 2730, 2780
  280. 2720 LET NUM=AND((NUM-1),63)
  281. 2730 IF N<>NUM THEN RETURN
  282. 2740 LET NUMTRY=0 \ N=AND((N+1),63) \ COMP=COMP+1
  283. 2750 GOSUB 1260 : FILL BUFFER, RETURN SIZE
  284. 2760 LET SIZ=LEN(PACKET$)
  285. 2770 LET STATE=ASC("D")
  286. 2780 RETURN
  287. 2790 LET STATE=ASC("A")
  288. 2800 RETURN
  289. 2810 REM **************
  290. 2820 REM SEND DATA FILE
  291. 2830 REM **************
  292. 2840 LET TYPE=ASC("D") \ NUM=N \ LENGTH=SIZ \ DATA$=PACKET$
  293. 2850 IF NUMTRY>MAXTRY THEN GOTO 3040
  294. 2860 LET NUMTRY=NUMTRY+1
  295. 2870 GOSUB 1520 : SEND PACKET TO OTHER END - CALL BY NAME
  296. 2880 GOSUB 1730 :            RECEIVE PACKET, STORE LEN,NUM ET RETURN TYPE
  297. 2890 LET RECPKT$=DATAX$
  298. 2900 LET H$=CHR$(TYPE)
  299. 2910 LET K=POS("NY",H$,1)+1
  300. 2920 ON K THEN GOTO 2930, 2930, 2960, 2930
  301. 2930 LET TYPE=ASC("D")
  302. 2940 LET LENGTH=SIZ \ DATA$=B$ \ NUM=N
  303. 2950 GOTO 2850
  304. 2960 IF N<>NUM THEN GOTO 2930
  305. 2970 LET OLDTRY=NUMTRY \ NUMTRY=0 \ N=AND((N+1),63) \ COMP=COMP+1
  306. 2980 GOSUB 1260 : FILL BUFFER, RETURN SIZE
  307. 2990 LET PACKET$=B$
  308. 3000 LET SIZ=LEN(PACKET$)
  309. 3010 IF SIZ=0 THEN GOTO 3060
  310. 3020 LET STATE=ASC("D")
  311. 3030 RETURN
  312. 3040 LET STATE=ASC("A")
  313. 3050 RETURN
  314. 3060 LET STATE=ASC("Z")
  315. 3070 RETURN
  316. 3080 REM ****************
  317. 3090 REM SEND END-OF-FILE
  318. 3100 REM ****************
  319. 3110 IF NUMTRY>MAXTRY THEN GOTO 3270
  320. 3120 LET NUMTRY=NUMTRY+1
  321. 3130 LET TYPE=ASC("Z") \ NUM=N \ LENGTH=0 \ DATA$=""
  322. 3140 GOSUB 1520 : SEND PACKET TO OTHER END - CALL BY NAME
  323. 3150 GOSUB 1730 :            RECEIVE PACKET, STORE LEN,NUM ET RETURN TYPE
  324. 3160 LET RECPKT$=DATAX$
  325. 3170 LET H$=CHR$(TYPE)
  326. 3180 LET K=POS("NY",H$,1)+1
  327. 3190 ON K THEN GOTO 3270, 3200, 3210, 3260
  328. 3200 LET NUM=AND((NUM-1),63)
  329. 3210 IF N<>NUM THEN RETURN
  330. 3220 LET NUMTRY=0 \ N=AND((N+1),63) \ COMP=COMP+1
  331. 3230 CLOSE FILE[2]
  332. 3240 IF NFILE<>1 THEN GOTO 3290
  333. 3250 LET STATE=ASC("F") \ OK=1
  334. 3260 RETURN
  335. 3270 LET STATE=ASC("A")
  336. 3280 RETURN
  337. 3290 LET STATE=ASC("B")
  338. 3300 RETURN
  339. 3310 REM ****************
  340. 3320 REM SEND BREAK (EOT)
  341. 3330 REM ****************
  342. 3340 IF NUMTRY>MAXTRY THEN GOTO 3470
  343. 3350 LET TYPE=ASC("B") \ NUM=N \ LENGTH=0 \ DATA$=""
  344. 3360 LET NUMTRY=NUMTRY+1
  345. 3370 GOSUB 1520 : SEND PACKET TO OTHER END - CALL BY NAME
  346. 3380 GOSUB 1730 :            RECEIVE PACKET, STORE LEN,NUM ET RETURN TYPE
  347. 3390 LET RECPKT$=DATAX$
  348. 3400 LET H$=CHR$(TYPE)
  349. 3410 LET K=POS("NY",H$,1)+1
  350. 3420 ON K THEN GOTO 3470, 3430, 3440, 3460
  351. 3430 LET NUM=AND((NUM-1),63)
  352. 3440 IF N<>NUM THEN RETURN
  353. 3450 LET NUMTRY=0 \ N=AND((N+1),63) \ STATE=ASC("C") \ COMP=COMP+1
  354. 3460 RETURN
  355. 3470 LET STATE=ASC("A")
  356. 3480 RETURN
  357. 3490 REM **************************************
  358. 3500 REM STATE TABLE SWITCHER FOR RECEIVE FILES
  359. 3510 REM **************************************
  360. 3520 LET FIL=0 \ STATE=ASC("R") \ N=0 \ NUMTRY=0 \ COMP=0
  361. 3530 IF DEBUG THEN GOSUB 3680
  362. 3550 LET H$=CHR$(STATE)
  363. 3560 LET K=POS("DFRCA",H$,1)+1
  364. 3570 ON K THEN GOTO 3575, 3580, 3600, 3620, 3640, 3660
  365. 3575 LET STATE=FALSE
  366. 3577 RETURN
  367. 3580 GOSUB 4380 : RECEIVE DATA
  368. 3590 GOTO 3550
  369. 3600 GOSUB 3950 : RECEIVE FILE HEADER
  370. 3610 GOTO 3550
  371. 3620 GOSUB 3710 : RECEIVE INITIALIZATION
  372. 3630 GOTO 3550
  373. 3640 LET STATE=TRUE
  374. 3650 RETURN
  375. 3660 LET STATE=FALSE
  376. 3670 RETURN
  377. 3680 OPEN FILE[6,0],"LOG.LOG"
  378. 3690 RETURN
  379. 3700 REM **********************
  380. 3710 REM RECEIVE INITIALIZATION
  381. 3720 REM **********************
  382. 3730 IF NUMTRY>MAXTRY THEN GOTO 3920
  383. 3740 LET NUMTRY=NUMTRY+1
  384. 3750 LET MESSAG$=""
  385. 3760 GOSUB 5540 : GET LA LIGNE AU COMPLET
  386. 3770 GOSUB 1730 :            RECEIVE PACKET, STORE LEN,NUM ET RETURN TYPE
  387. 3780 LET PACKET$=DATAX$
  388. 3790 IF TYPE<>ASC("S") THEN GOTO 3880
  389. 3800 LET S$=PACKET$
  390. 3810 GOSUB 0730 : UNPACK DATA FROM OTHER END
  391. 3820 GOSUB 0680 : SEND MY PARAMETERS TO OTHER END
  392. 3830 LET PACKET$=SPAR$
  393. 3840 LET TYPE=ASC("Y") \ NUM=N \ LENGTH=9 \ DATA$=PACKET$
  394. 3850 GOSUB 1520 : SEND PACKET TO OTHER END - CALL BY NAME
  395. 3860 LET OLDTRY=NUMTRY \ NUMTRY=0 \ N=AND((N+1),63) \ STATE=ASC("F")
  396. 3865 LET COMP=COMP+1
  397. 3870 RETURN
  398. 3880 LET TYPE=ASC("N") \ NUM=N \ LENGTH=0 \ DATA$="" \ NUMTRY=NUMTRY+1
  399. 3890 IF NUMTRY>MAXTRY THEN GOTO 3920
  400. 3900 GOSUB 1520 : SEND PACKET TO OTHER END - CALL BY NAME
  401. 3910 GOTO 3770
  402. 3920 LET STATE=ASC("A")
  403. 3930 RETURN
  404. 3940 REM *******************
  405. 3950 REM RECEIVE FILE HEADER
  406. 3960 REM *******************
  407. 3970 IF NUMTRY>MAXTRY THEN GOTO 4350
  408. 3980 LET NUMTRY=NUMTRY+1
  409. 3990 GOSUB 1730 :            RECEIVE PACKET, STORE LEN,NUM ET RETURN TYPE
  410. 4000 LET PACKET$=DATAX$
  411. 4010 LET H$=CHR$(TYPE)
  412. 4020 LET K=POS("SZFB",H$,1)+1
  413. 4030 ON K THEN GOTO 4040, 4070, 4150, 4220, 4300, 4330
  414. 4040 LET STATE=ASC("N") \ NUM=N \ LENGTH=0 \ DATA$=""
  415. 4050 GOSUB 1520 : SEND PACKET TO OTHER END - CALL BY NAME
  416. 4060 GOTO 3990
  417. 4070 LET OLDTRY=OLDTRY+1
  418. 4080 IF OLDTRY>MAXTRY THEN GOTO 4040
  419. 4090 LET STATE=ASC("R") \ N,COMP=0
  420. 4100 RETURN
  421. 4110 LET PACKET$=SPAR$ \ TYPE=ASC("Y") \ NUM=N \ LENGTH=6 \ DATA$=PACKET$
  422. 4120 GOSUB 1520 : SEND PACKET TO OTHER END - CALL BY NAME
  423. 4130 LET NUMTRY=0
  424. 4140 RETURN
  425. 4150 LET OLDTRY=OLDTRY+1
  426. 4160 IF OLDTRY>MAXTRY THEN GOTO 4040
  427. 4170 IF NUM<>AND((N+1),63) THEN GOTO 4040
  428. 4180 LET TYPE=ASC("Y") \ NUM=N \ LENGTH=0 \ DATA$=""
  429. 4190 GOSUB 1520 : SEND PACKET TO OTHER END - CALL BY NAME
  430. 4200 LET NUMTRY=0
  431. 4210 RETURN
  432. 4220 IF NUM<>N THEN GOTO 4040
  433. 4230 LET AA$=PACKET$
  434. 4240 PRINT @(11,40);"FILE NAME: ";AA$
  435. 4250 GOSUB 5310 : CREATE NEW FILE
  436. 4260 LET TYPE=ASC("Y") \ NUM=N \ LENGTH=0 \ DATA$=""
  437. 4270 GOSUB 1520 : SEND PACKET TO OTHER END - CALL BY NAME
  438. 4280 LET OLDTRY=NUMTRY \ NUMTRY=0 \ N=AND((N+1),63) \ STATE=ASC("D")
  439. 4285 LET COMP=COMP+1
  440. 4290 RETURN
  441. 4300 IF NUM<>N THEN GOTO 4040
  442. 4310 LET TYPE=ASC("Y") \ NUM=N \ LENGTH=0 \ DATA$="" \ STATE=ASC("C") \ FIN=1
  443. 4320 GOSUB 1520 : SEND PACKET TO OTHER END - CALL BY NAME
  444. 4330 RETURN
  445. 4340 PRINT @(15,1);"COULD NOT CREATE";PACKET$
  446. 4350 LET STATE=ASC("A")
  447. 4360 RETURN
  448. 4370 REM ************
  449. 4380 REM RECEIVE DATA
  450. 4390 REM ************
  451. 4400 IF NUMTRY>MAXTRY THEN GOTO 4780
  452. 4410 LET NUMTRY=NUMTRY+1
  453. 4420 GOSUB 1730 :            RECEIVE PACKET, STORE LEN,NUM ET RETURN TYPE
  454. 4430 LET PACKET$=DATAX$
  455. 4440 LET H$=CHR$(TYPE)
  456. 4450 LET K=POS("DFZ",H$,1)+1
  457. 4460 ON K THEN GOTO 4750, 4470, 4600, 4690, 4770
  458. 4470 IF NUM=N THEN GOTO 4550 ELSE LET OLDTRY=OLDTRY+1
  459. 4480 IF OLDTRY>MAXTRY THEN GOTO 4780
  460. 4490 IF NUM=AND((N-1),63) THEN GOTO 4510
  461. 4500 IF NUM<>N THEN GOTO 4750
  462. 4510 LET TYPE=ASC("Y") \ LENGTH=0 \ DATA$="" \ NUMTRY=NUMTRY+1
  463. 4520 GOSUB 1520 : SEND PACKET TO OTHER END - CALL BY NAME
  464. 4530 LET NUMTRY=0
  465. 4540 RETURN
  466. 4550 GOSUB 0840 : UNPACK A PACKET TO FILE
  467. 4560 LET TYPE=ASC("Y") \ LENGTH=0 \ DATA$="" \ NUM=N
  468. 4570 GOSUB 1520 : SEND PACKET TO OTHER END - CALL BY NAME
  469. 4580 LET OLDTRY=NUMTRY \ NUMTRY=0 \ N=AND((N+1),63) \ STATE=ASC("D")
  470. 4585 LET COMP=COMP+1
  471. 4590 RETURN
  472. 4600 LET OLDTRY=OLDTRY+1
  473. 4610 IF OLDTRY>MAXTRY THEN GOTO 4780
  474. 4620 IF NUM=AND((N-1),63) THEN GOTO 4650
  475. 4630 LET STATE=ASC("A")
  476. 4640 RETURN
  477. 4650 LET TYPE=ASC("Y") \ LENGTH=0 \ DATA$=""
  478. 4660 GOSUB 1520 : SEND PACKET TO OTHER END - CALL BY NAME
  479. 4670 LET NUMTRY=0
  480. 4680 RETURN
  481. 4690 IF NUM<>N THEN GOTO 4780
  482. 4700 LET TYPE=ASC("Y") \ NUM=N \ LENGTH=0 \ DATA$=""
  483. 4710 GOSUB 1520 : SEND PACKET TO OTHER END - CALL BY NAME
  484. 4720 CLOSE FILE[2]
  485. 4730 LET N=AND((N+1),63) \ STATE=ASC("F") \ COMP=COMP+1
  486. 4740 RETURN
  487. 4750 LET TYPE=ASC("N") \ LENGTH=0 \ DATA$=""
  488. 4760 GOSUB 1520 : SEND PACKET TO OTHER END - CALL BY NAME
  489. 4770 GOTO 4400
  490. 4780 LET STATE=ASC("A")
  491. 4790 RETURN
  492. 4800 REM *****************************************
  493. 4810 REM SET PORT I/O
  494. 4820 REM *****************************************
  495. 4830 IF PORT=2 THEN GOTO 4850
  496. 4835 LET PORT,ENV%=2
  497. 4840 GOTO 0350
  498. 4850 LET PORT,ENV%=5
  499. 4860 GOTO 0350
  500. 4930 REM ******************************
  501. 4940 REM INPUT FILE NAMES - CHECK FILES
  502. 4950 REM ******************************
  503. 4960 INPUT USING "",@(13,1),"SPECIFY FILE NAMES:",@(-10,-60),AA$
  504. 4970 IF LEN(AA$)<>0 THEN GOTO 5000
  505. 4980 LET NFILE=0
  506. 4990 RETURN
  507. 5000 REM
  508. 5010 LET K=POS(AA$,",",1)
  509. 5020 IF K THEN LET FILE$=AA$[1,K-1] \ AA$=AA$[(K+1),LEN(AA$)] \ NFILE=1 \ BLOC=0
  510. 5030 IF K THEN GOTO 5050 : ON ERR THEN GOTO 3970
  511. 5040 LET FILE$=AA$ \ NFILE=0 \ BLOC,W=0
  512. 5045 LET K=POS(FILE$,"/",1)
  513. 5047 IF K THEN GOTO 5100
  514. 5050 REM ON ERR THEN GOTO 3970
  515. 5060 OPEN FILE[2,4],FILE$
  516. 5070 RETURN
  517. 5080 PRINT @(14,1);"FILE ";FILE$;" DOES NOT EXIST - ABORT !!!!!!"
  518. 5090 LET NFILE=-1
  519. 5095 RETURN
  520. 5100 LET LREC=VAL(FILE$[K+1,LEN(FILE$)],W)
  521. 5101 LET FILE$=FILE$[1,K-1],FILL$(32)
  522. 5102 OPEN FILE[2,6],FILE$
  523. 5104 POSITION FILE[2,6]
  524. 5105 READ FILE[2],LAST
  525. 5106 POSITION FILE[2,0]
  526. 5107 IF LREC=300 THEN POSITION FILE[2,LREC]
  527. 5108 RETURN
  528. 5110 REM ************************
  529. 5120 REM GET LINE CHAR ONE BY ONE
  530. 5130 REM ************************
  531. 5140 LET V=V+1
  532. 5150 LET T=ASC(INCHR$[V,V])
  533. 5160 RETURN
  534. 5170 REM **************************
  535. 5180 REM PRINT MENU - INPUT COMMAND
  536. 5190 REM **************************
  537. 5200 PRINT @(1,1);"   K E R M I T    F O R    S U P E R D O S "
  538. 5210 PRINT @(-28);@(-28)
  539. 5220 PRINT @(4,1);"P   PORT I/O                         DEBUG: ";DEBUG$
  540. 5230 PRINT @(5,1);"R   RECEIVE FILES FROM HOST          PORT: ";PORT
  541. 5240 PRINT @(6,1);"S   SEND FILES TO HOST"
  542. 5250 PRINT @(7,1);"D   DEBUG MODE"
  543. 5260 PRINT @(8,1);"E   EXIT KERMIT"
  544. 5270 INPUT USING "",@(11,1),"SPECIFY FUNCTION :",@(-10,-1),F$
  545. 5280 LET F=(POS("PpRrSsEeDd",F$,1)+1)/2
  546. 5290 IF F=0 THEN GOTO 5270 ELSE RETURN
  547. 5300 REM ***************
  548. 5310 REM CREATE NEW FILE
  549. 5320 REM ***************
  550. 5322 LET K=POS(AA$,".",1)
  551. 5324 IF K THEN LET AA$=AA$[1,K-1],FILL$(32)
  552. 5330 OPEN FILE[2,0],AA$
  553. 5340 RETURN
  554. 5350 REM ****************
  555. 5360 REM QUOTE 8 BIT
  556. 5370 REM ****************
  557. 5380 LET H2$="&",CHR$(AND(ASC(H$),127)) \ H1$="&"
  558. 5390 RETURN
  559. 5400 REM ***************************
  560. 5410 REM QUOTE A CHAR "#" AND "&"
  561. 5420 REM ***************************
  562. 5430 LET H3$=H1$,"#",H$
  563. 5440 RETURN
  564. 5450 REM *********************
  565. 5460 REM QUOTE CHAR CONTROL
  566. 5470 REM *********************
  567. 5480 IF I>1 THEN LET H4$=H3$[1,I-1] ELSE LET H4$=""
  568. 5490 LET H=OR(ASC(H$),64)
  569. 5500 IF AND(ASC(H$),64) THEN LET H=H-64
  570. 5510 LET H4$=H4$,"#",CHR$(H,1)
  571. 5520 RETURN
  572. 5530 REM *******************************
  573. 5540 REM GET LA LIGNE AU COMPLET
  574. 5550 REM *******************************
  575. 5560 IF FIN THEN GOTO 5640
  576. 5570 LET REPLY$=""
  577. 5580 IF DEBUG THEN WRITE FILE[6],MESSAG$
  578. 5590 STMD 1,ENV%,50,MESSAG$,REPLY$
  579. 5600 IF SYS(22)=0 THEN IF CTES>30 THEN GOTO 0600 ELSE GOTO 5660
  580. 5610 IF DEBUG THEN WRITE FILE[6],REPLY$
  581. 5620 LET INCHR$=REPLY$[1,LEN(REPLY$)] \ CTES=0
  582. 5630 RETURN
  583. 5640 STMD 1,ENV%,0,MESSAG$
  584. 5650 RETURN
  585. 5660 LET CTES=CTES+1
  586. 5670 GOTO 5590
  587.  
  588.