home *** CD-ROM | disk | FTP | other *** search
/ Club Amiga de Montreal - CAM / CAM_CD_1.iso / files / 427.lha / pmdcom / sources / pc8.c < prev    next >
Encoding:
C/C++ Source or Header  |  1990-10-08  |  31.4 KB  |  1,116 lines
  1.  
  2. /* pmdcom.c ,Lattice 5.04, public domain-use it,abuse it,lose it */
  3. /* Paul DePetrillo   August, 1990  */
  4. /*  with some help from Rush,Pink Floyd,Mr. Big, MSG, etc.  */
  5.  
  6.  
  7. #include "pc8.h"
  8.  
  9. VOID main(argc,argv)
  10. int argc;
  11. char **argv;
  12. {
  13.     if (argc >1 && argv[1][0]=='w') custom=0;
  14.     doinit();
  15.     asyncRexxCmd("init");
  16.     SendIO((struct IORequest *)serread_req);
  17.     while(go)
  18.     {
  19.         signals=Wait(windowmask|serialmask|rexxbit);
  20.         if (CheckIO((struct IORequest *)serread_req)) doserial();
  21.         if (signals & windowmask ) dowindow();
  22.         if (signals & rexxbit)   dispRexxPort();
  23.     }
  24.     cleanup(24);
  25. }
  26.  
  27. void doserial()
  28. {
  29.     int actual,i,p,a;
  30.     actual=readserial();
  31.     if (hostmon) {                /* where the protocol autostarts */
  32.         actual=XProtocolHostMon(&io,&serbuf[0],actual,512);
  33.         if (actual==0) {
  34.             serread_req->IOSer.io_Data=(APTR)&serbuf[0];
  35.             serread_req->IOSer.io_Length=1;
  36.             SendIO((struct IORequest *)serread_req);
  37.             return;
  38.         }
  39.     }
  40.     for (i=0;i<actual;i++) {
  41.         serbuf[i] = serbuf[i] & 0x7f;     /* strip high bit */
  42.         if (serbuf[i]<32) {
  43.             switch (serbuf[i])
  44.             {
  45.                 case 7:
  46.                 case 8:
  47.                 case 10:
  48.                 case 12:
  49.                 case 13:
  50.                 case 27:
  51.                     break;
  52.                 default:                  /* convert garbage to spaces */
  53.                     serbuf[i]=32;
  54.             }
  55.         }
  56.     }
  57.     conwrite_req->io_Data=(APTR)&serbuf[0];
  58.     conwrite_req->io_Length=actual;
  59.     DoIO((struct IORequest *)conwrite_req);
  60.     p=actual;
  61.     i=0;
  62.     if (capture) {                  /* capture to file with 4k buffer */
  63.         while (p>0) {
  64.             if ( txtpos==4096 ) {
  65.                 a=fwrite(&txtbuf[0],512,8,fp);
  66.                 if (a < 8) {
  67.                     fclose(fp);
  68.                     printstr("\nError writing to file.\n");
  69.                     capture=0;
  70.                 }
  71.                 txtpos=0;
  72.             }
  73.             txtbuf[txtpos++]=serbuf[i++];
  74.             --p;
  75.         }
  76.     }
  77.     serread_req->IOSer.io_Data=(APTR)&serbuf[0];
  78.     serread_req->IOSer.io_Length=1;
  79.     SendIO((struct IORequest *)serread_req);
  80.  
  81. }
  82.  
  83. int readserial()
  84. {
  85.         int len,actual;
  86.         serret=(struct IOExtSer *)GetMsg((struct MsgPort *)serial_portr);
  87.         actual=1;
  88.         serread_req->IOSer.io_Command=SDCMD_QUERY;
  89.         DoIO((struct IORequest *)serread_req);
  90.         serread_req->IOSer.io_Command=CMD_READ;
  91.         len=(struct IORequest *)serread_req->IOSer.io_Actual;
  92.         if (len>0)  {
  93.             if (len>511) len=511;
  94.             serread_req->IOSer.io_Data=(APTR)&serbuf[1];
  95.             serread_req->IOSer.io_Length=len;
  96.             DoIO((struct IORequest *)serread_req);
  97.             actual=actual+len;
  98.         }
  99.         return(actual);
  100. }
  101.  
  102. VOID dowindow()
  103. {
  104.     while(message=(struct IntuiMessage *)GetMsg(window->UserPort))
  105.     {
  106.         mclass=message->Class;
  107.         mcode=message->Code;
  108.         iaddress=message->IAddress;
  109.         ReplyMsg((struct Message *)message);
  110.         switch (mclass) {
  111.             case MENUPICK:
  112.                 domenu();
  113.                 break;
  114.             case VANILLAKEY:
  115.                 key=(USHORT)mcode;
  116.                 serwrite_req->IOSer.io_Data=(APTR)&key;
  117.                 serwrite_req->IOSer.io_Length=1;
  118.                 DoIO((struct IORequest *)serwrite_req);
  119.                 break;
  120.             default:
  121.                 break;
  122.         }
  123.     }
  124.     if (doup) {             /* enter protocol from here */
  125.         doupload(NULL);     /* instead of domenu */
  126.         doup=0;
  127.     }
  128.     if (dodwn) {
  129.         dodownload(NULL);
  130.         dodwn=0;
  131.     }
  132. }
  133.  
  134. VOID domenu()
  135. {
  136.     long status;
  137.     char tbuffer[75];
  138.     while(mcode!=MENUNULL) {
  139.         switch(MENUNUM(mcode)) {
  140.             case 0:
  141.                 switch(ITEMNUM(mcode)) {
  142.                     case 0:
  143.                         Request(&myreq,window);
  144.                         break;
  145.                     case 1:
  146.                         ColorRequester(1L);
  147.                         break;
  148.                     case 2:
  149.                         if (custom) {
  150.                             if (tit) {
  151.                                 ShowTitle(screen,FALSE);
  152.                                 tit=0;}
  153.                             else {
  154.                                 ShowTitle(screen,TRUE);
  155.                                 tit=1;}
  156.                         }
  157.                         else {
  158.                             strcpy(&tbuffer[0],"");
  159.                             status=GetString(&tbuffer[0],(char *)"Title?", window, 50, 74);
  160.                             if (status==TRUE) SetWindowTitles(window,&tbuffer[0],NULL);
  161.                         }
  162.                         break;
  163.                     case 3:
  164.                         go=0;       /* user chose quit */
  165.                         break;
  166.                 }
  167.                 break;
  168.             case 1:
  169.                 switch(ITEMNUM(mcode)) {
  170.                     case 0:
  171.                         if (capture) closecapture();
  172.                         else opencapture(NULL);
  173.                         break;
  174.                     case 1:
  175.                         dodwn=1;
  176.                         break;
  177.                     case 2:
  178.                         doup=1;
  179.                         break;
  180.                     case 3:
  181.                         doprotocol(NULL,NULL);
  182.                         break;
  183.                 }
  184.                 break;
  185.             case 2:
  186.                 switch(ITEMNUM(mcode)) {
  187.                     case 0:
  188.                         switch(SUBNUM(mcode)) {
  189.                             case 0:
  190.                                 baud=1200;
  191.                                 break;
  192.                             case 1:
  193.                                 baud=2400;
  194.                                 break;
  195.                             case 2:
  196.                                 baud=9600;
  197.                                 break;
  198.                         }
  199.                         break;
  200.                     case 1:
  201.                         set=(SUBNUM(mcode)+1);
  202.                         break;
  203.                 }
  204.                 setserial(baud,set);
  205.                 break;
  206.             case 3:
  207.                 asyncRexxCmd(&cmd[(ITEMNUM(mcode)*50)]);  /*run a macro*/
  208.                 break;
  209.         } /* end switch(menunum) */
  210.         mitem=(struct MenuItem *)ItemAddress((struct Menu *)&mstrip,mcode);
  211.         mcode=mitem->NextSelect;
  212.     }      /* end while menucode!=menunull */
  213. }       /* end domenu() */
  214.  
  215. VOID dodownload(filen)
  216. char *filen;
  217. {
  218.     int success;
  219.     if (XProtocolBase==NULL) {
  220.         if (filen==NULL) {
  221.             printstr("\nError: no protocol selected.\n");
  222.             return;}
  223.         else {
  224.             ohshit=10;   /* rexx return code */
  225.             return;}
  226.     }
  227.     if (rxreq & (filen==NULL)) {
  228.         myfilereq.Title=(UBYTE *)"Download to file:";
  229.         success=FileRequester(&myfilereq);
  230.         if (success==FALSE) return;
  231.         io.xpr_filename=&frpath[0];
  232.     }
  233.     else io.xpr_filename=filen;
  234.     printstr("\nWaiting for start...\n");
  235.     AbortIO((struct IORequest *)serread_req);
  236.     Wait(serialmask);
  237.     WaitIO((struct IORequest *)serread_req);
  238.     err=XProtocolReceive(&io);
  239.     if (err && filen) ohshit=15;
  240.     serread_req->IOSer.io_Data=(APTR)&serbuf[0];
  241.     serread_req->IOSer.io_Length=1;
  242.     SendIO((struct IORequest *)serread_req);
  243.     SetWindowTitles(window,0,0);
  244. }
  245.  
  246. VOID doupload(filen)
  247. char *filen;
  248. {
  249.     int success;
  250.     if (XProtocolBase==NULL) {
  251.         if (filen==NULL) {
  252.             printstr("\nError: no protocol selected.\n");
  253.             return;}
  254.         else {
  255.             ohshit=10;
  256.             return;}
  257.     }
  258.     if (sendreq & (filen==NULL)) {
  259.         myfilereq.Title=(UBYTE *)"Upload File:";
  260.         success=FileRequester(&myfilereq);
  261.         if (success==FALSE) return;
  262.         else io.xpr_filename=&frpath[0];
  263.     }
  264.     else io.xpr_filename=filen;
  265.     AbortIO((struct IORequest *)serread_req);
  266.     Wait(serialmask);
  267.     WaitIO((struct IORequest *)serread_req);
  268.     printstr("\nWaiting for start...\n");
  269.     err=XProtocolSend(&io);
  270.     if (err) ohshit=15;
  271.     serread_req->IOSer.io_Data=(APTR)&serbuf[0];
  272.     serread_req->IOSer.io_Length=1;
  273.     SendIO((struct IORequest *)serread_req);
  274.     SetWindowTitles(window,0,0);
  275. }
  276.  
  277. VOID doprotocol(proto,op)
  278. char *proto;
  279. char *op;
  280. {
  281.     int success;
  282.     char t[3];
  283.     t[0]=34;
  284.     t[1]=34;
  285.     t[2]=0;
  286.     if (proto==NULL) {
  287.         myfilereq.Title=(UBYTE *)"Select Protocol:";
  288.         strcpy(&frdir[0],(char *)"libs:");
  289.         myfilereq.Dir=&frdir[0];
  290.         strcpy(myfilereq.Show,(char *)"xpr#?.library");
  291.         myfilereq.File=&frfile[0];
  292.         myfilereq.PathName=&frpath[0];
  293.         success=FileRequester(&myfilereq);
  294.         strcpy(&frdir[0],(char *)"");
  295.         strcpy(myfilereq.Show,(char *)"#?");
  296.         if (success==FALSE) return;
  297.     }
  298.     else strcpy(&frpath[0],proto);
  299.     if (XProtocolBase != NULL) {
  300.              XProtocolCleanup(&io);
  301.              CloseLibrary(XProtocolBase);
  302.     }
  303.     XProtocolBase=OpenLibrary((char *)&frpath[0],0);
  304.     if (XProtocolBase==NULL) {
  305.         ohshit=10;
  306.         printstr("\nError: could not open library.\n");
  307.         return;
  308.     }
  309.     io.xpr_update=xupdate;
  310.     io.xpr_fopen=xfopen;
  311.     io.xpr_fclose=xfclose;
  312.     io.xpr_fread=xfread;
  313.     io.xpr_fwrite=xfwrite;
  314.     io.xpr_finfo=xfinfo;
  315.     io.xpr_fseek=xfseek;
  316.     io.xpr_sread=xsread;
  317.     io.xpr_swrite=xswrite;
  318.     io.xpr_sflush=xsflush;
  319.     io.xpr_gets=xgets;
  320.     io.xpr_chkabort=xchkabort;
  321.     if (proto==NULL) io.xpr_filename=NULL;
  322.     else io.xpr_filename=op;
  323.     err=XProtocolSetup(&io);
  324.     if (err == XPRS_FAILURE) {
  325.             XProtocolCleanup(&io);
  326.             CloseLibrary(XProtocolBase);
  327.             printstr("Error: protocol failed to initialize. Library closed.\n");
  328.             hostmon=0;
  329.             ohshit=10;
  330.             return;
  331.     }
  332.     if (err & XPRS_HOSTMON) hostmon=1;
  333.     else hostmon=0;
  334.     if (err & XPRS_NORECREQ) rxreq=0;
  335.     else rxreq=1;
  336.     if (err & XPRS_NOSNDREQ) sendreq=0;
  337.     else sendreq=1;
  338. }
  339.  
  340. VOID opencapture(file)
  341. char *file;
  342. {
  343.     int success;
  344.     if (file==NULL) {
  345.         myfilereq.Title=(UBYTE *)"Capture to file:";
  346.         success=FileRequester(&myfilereq);
  347.         if (success==FALSE) return;
  348.     }
  349.     else strcpy(&frpath[0],file);
  350.     fp=fopen(&frpath[0],"w");
  351.     if (fp==NULL) {
  352.             printstr("\nError:could not open file.\n");
  353.             ohshit=10;
  354.             return;
  355.     }
  356.     capture=1;
  357.     txtpos=0;
  358. }
  359.  
  360. VOID closecapture()
  361. {
  362.         if (capture==0) return;
  363.         if (txtpos==4096) fwrite(&txtbuf[0],512,8,fp);
  364.         else {
  365.                 txtbuf[txtpos]=0;
  366.                 fputs(&txtbuf[0],fp);}
  367.         fclose(fp);
  368.         capture=0;
  369. }
  370.  
  371. VOID printstr(str)
  372. char *str;
  373. {
  374.         conwrite_req->io_Data=(APTR)str;
  375.         conwrite_req->io_Length=-1;
  376.         DoIO((struct IORequest *)conwrite_req);
  377. }
  378.  
  379. VOID cleanup(anum)
  380. int anum;
  381. {
  382.         dnRexxPort();
  383.         closecapture();
  384.         switch(anum) {
  385.                 case 24:
  386.                  if (XProtocolBase) XProtocolCleanup(&io);
  387.                 case 23:
  388.                  if (XProtocolBase) CloseLibrary(XProtocolBase);
  389.                 case 22:
  390.                  CloseDevice((struct IORequest *)timerreq);
  391.                 case 21:
  392.                  DeleteExtIO( (struct IORequest *)timerreq);
  393.                 case 20:
  394.                  DeletePort((struct MsgPort *)timer_port);
  395.                 case 19:
  396.                  CloseDevice((struct IORequest *)serread_req);
  397.                 case 18:
  398.                  CloseDevice((struct IORequest *)serwrite_req);
  399.                 case 17:
  400.                  FreeMem(serread_req,sizeof(struct IOExtSer));
  401.                 case 16:
  402.                  FreeMem(serwrite_req,sizeof(struct IOExtSer));
  403.                 case 15:
  404.                  DeletePort((struct MsgPort *)serial_portr);
  405.                 case 14:
  406.                  DeletePort((struct MsgPort *)serial_portw);
  407.                 case 13:
  408.                 case 12:
  409.                  CloseDevice((struct IORequest *)conwrite_req);
  410.                 case 11:
  411.                 case 10:
  412.                  DeleteStdIO(conwrite_req);
  413.                 case 9:
  414.                 case 8:
  415.                  DeletePort((struct MsgPort *)console_portw);
  416.                 case 7:
  417.                  if (custom) myprocess->pr_WindowPtr=oldwin;
  418.                  ClearMenuStrip(window);
  419.                  CloseWindow(window);
  420.                 case 5:
  421.                  if (screen) CloseScreen(screen);
  422.                 case 3:
  423.                  CloseLibrary(ReqBase);
  424.                 case 2:
  425.                  CloseLibrary(IntuitionBase);
  426.                 case 1:
  427.                  exit(1);
  428.         }
  429. }
  430.  
  431. VOID doinit()
  432. {
  433.     int error;
  434.     IntuitionBase=OpenLibrary("intuition.library",0);
  435.     if ( IntuitionBase==NULL ) cleanup(1);
  436.     ReqBase=OpenLibrary("req.library",0);
  437.     if (ReqBase==NULL) cleanup(2);
  438.     if (custom) {
  439.         screen=(struct Screen *)OpenScreen(&cns);
  440.         if (screen==NULL) cleanup(3);
  441.         cnw.Screen=screen;
  442.         window=(struct Window *)OpenWindow(&cnw);
  443.         if ( window==NULL ) cleanup(5);
  444.         ShowTitle(screen,FALSE);
  445.         SetMenuStrip(window,(struct Menu *)&mstrip);
  446.         myprocess=(struct Process *)FindTask(0);
  447.         oldwin=(struct Window *)myprocess->pr_WindowPtr;
  448.         myprocess->pr_WindowPtr=(APTR)window;
  449.     }
  450.     else {
  451.         window=(struct Window *)OpenWindow(&wnw);
  452.         if ( window==NULL ) cleanup(3);
  453.         SetMenuStrip(window,(struct Menu *)&mstrip);
  454.     }
  455.         console_portw=(struct MsgPort *)CreatePort("conportw",0);
  456.         if ( console_portw==NULL ) cleanup(7);
  457.         conwrite_req=(struct IOStdReq *)CreateStdIO((struct MsgPort *)console_portw);
  458.         if ( conwrite_req==NULL ) cleanup(9);
  459.         conwrite_req->io_Data=(APTR)window;
  460.         conwrite_req->io_Length=sizeof(*window);
  461.         error=OpenDevice("console.device",0,(struct IORequest *)conwrite_req,0);
  462.         if ( error != 0 ) cleanup(11);
  463.         conwrite_req->io_Command=CMD_WRITE;
  464.  
  465.         serial_portw=(struct MsgPort *)CreatePort("serportw",0);
  466.         if ( serial_portw==NULL ) cleanup(13);
  467.         serial_portr=(struct MsgPort *)CreatePort("serportr",0);
  468.         if ( serial_portr==NULL ) cleanup(14);
  469.  
  470.         serwrite_req=(struct IOExtSer *)AllocMem(sizeof(struct IOExtSer),MEMF_PUBLIC|MEMF_CLEAR);
  471.         if ( serwrite_req==NULL ) cleanup(15);
  472.         serwrite_req->IOSer.io_Message.mn_ReplyPort=serial_portw;
  473.         serwrite_req->io_SerFlags=SERF_SHARED|SERF_XDISABLED;
  474.  
  475.         serread_req=(struct IOExtSer *)AllocMem(sizeof(struct IOExtSer),MEMF_PUBLIC|MEMF_CLEAR);
  476.         if ( serread_req==NULL ) cleanup(16);
  477.         serread_req->IOSer.io_Message.mn_ReplyPort=serial_portr;
  478.         serread_req->io_SerFlags=SERF_SHARED|SERF_XDISABLED;
  479.  
  480.         error=OpenDevice("serial.device",0,(struct IORequest *)serwrite_req,0);
  481.         if (error != 0) cleanup(17);
  482.         error=OpenDevice("serial.device",0,(struct IORequest *)serread_req,0);
  483.         if (error != 0) cleanup(18);
  484.  
  485.         serread_req->io_Baud=1200;
  486.         serread_req->io_ReadLen=8;
  487.         serread_req->io_WriteLen=8;
  488.         serread_req->io_SerFlags &= ~SERF_PARTY_ON;
  489.         serread_req->IOSer.io_Command=SDCMD_SETPARAMS;
  490.         DoIO((struct IORequest *)serread_req);
  491.  
  492.         serwrite_req->IOSer.io_Command=CMD_WRITE;
  493.         serread_req->IOSer.io_Command=CMD_READ;
  494.         serread_req->IOSer.io_Data=(APTR)&serbuf[0];
  495.         serread_req->IOSer.io_Length=1;
  496.         serialmask=(1<<serial_portr->mp_SigBit);
  497.         windowmask=(1<<window->UserPort->mp_SigBit);
  498.  
  499.         timer_port=(struct MsgPort *)CreatePort("pdtimer",0);
  500.         if ( timer_port==NULL ) cleanup(19);
  501.         timerreq=(struct timerequest *)CreateExtIO(timer_port,sizeof(struct timerequest) );
  502.         if (timerreq==NULL) cleanup(20);
  503.         error=OpenDevice("timer.device",UNIT_VBLANK,(struct IORequest *)timerreq,0);
  504.         if (error) cleanup(21);
  505.         timermask=(1<<timer_port->mp_SigBit);
  506.  
  507.         rexxbit = upRexxPort("pmdcom", rcl, "pmd", &disp) ;
  508.         printstr("\n\n");
  509.         if (!(rexxbit)) printstr("Rexxport not active.");
  510.         baud=1200;
  511.         set=1;
  512.         capture=0;
  513.         txtpos=0;
  514.         strcpy(&words[0],(char *)"macro1");    /* what a waste */
  515.         strcpy(&words[50],(char *)"macro2");
  516.         strcpy(&words[100],(char *)"macro3");
  517.         strcpy(&words[150],(char *)"macro4");
  518.         strcpy(&words[200],(char *)"macro5");
  519.         strcpy(&words[250],(char *)"macro6");
  520.         strcpy(&words[300],(char *)"macro7");
  521.         strcpy(&words[350],(char *)"macro8");
  522.         strcpy(&words[400],(char *)"macro9");
  523.         strcpy(&words[450],(char *)"macro0");
  524.         strcpy(&cmd[0],(char *)"macro1");
  525.         strcpy(&cmd[50],(char *)"macro2");
  526.         strcpy(&cmd[100],(char *)"macro3");
  527.         strcpy(&cmd[150],(char *)"macro4");
  528.         strcpy(&cmd[200],(char *)"macro5");
  529.         strcpy(&cmd[250],(char *)"macro6");
  530.         strcpy(&cmd[300],(char *)"macro7");
  531.         strcpy(&cmd[350],(char *)"macro8");
  532.         strcpy(&cmd[400],(char *)"macro9");
  533.         strcpy(&cmd[450],(char *)"macro0");
  534.         myfilereq.Dir=&frdir[0];
  535.         myfilereq.File=&frfile[0];
  536.         myfilereq.PathName=&frpath[0];
  537. }
  538.  
  539.   /* here are the xpr routines */
  540.  
  541. long __saveds __regargs xsflush()
  542. {
  543.        long err;
  544.        serread_req->IOSer.io_Command=CMD_CLEAR;
  545.        DoIO((struct IORequest *)serread_req);
  546.        err=(UBYTE)serread_req->IOSer.io_Error;
  547.        serread_req->IOSer.io_Command=CMD_READ;
  548.        if (err) return(1);
  549.        else return(0);
  550. }
  551.  
  552. long __saveds __regargs xchkabort()
  553. {
  554.    int abort=0;
  555.    while(message=(struct IntuiMessage *)GetMsg(window->UserPort))
  556.    {
  557.         mclass=message->Class;
  558.         mcode=message->Code;
  559.         iaddress=message->IAddress;
  560.         ReplyMsg((struct Message *)message);
  561.         switch (mclass) {
  562.             case VANILLAKEY:
  563.                 key=(USHORT)mcode;
  564.                 if (key==0x1b) abort=1;
  565.                 break;
  566.             default:
  567.                 break;
  568.         }
  569.    }
  570.    if (abort) {
  571.       abort=0;
  572.       return(1);
  573.    }
  574.    else return(0);
  575. }
  576.  
  577. long __saveds __regargs xfinfo(filename,type)
  578. char *filename;
  579. long type;
  580. {
  581.         struct FileInfoBlock fib;
  582.         long ret;
  583.         if (type==2) return(1);    /* cheat, always say it's binary */
  584.         ret=dfind(&fib,filename,0);
  585.         if (ret) return(0);
  586.         ret=fib.fib_Size;
  587.         return(ret);
  588. }
  589.  
  590. long __saveds __regargs xgets(prompt,buffer)
  591. char *prompt,*buffer;
  592. {
  593.         long status;
  594.         status = GetString(buffer, prompt, window, 50, 255);
  595.         return(status);
  596. }
  597.  
  598. long __saveds __regargs xfopen(filename,accessmode)
  599. char *filename,*accessmode;
  600. {
  601.         long ret;
  602.         FILE *xfp;
  603.         xfp=fopen(filename,accessmode);
  604.         ret=(FILE *)xfp;
  605.         return(ret);
  606. }
  607.  
  608. long __saveds __regargs xfclose(xfp)
  609. FILE *xfp;
  610. {
  611.         long ret;
  612.         ret=fclose(xfp);
  613.         return(ret);
  614. }
  615.  
  616. long __saveds __regargs xfread(buf,size,count,xfp)
  617. char *buf;
  618. long size,count;
  619. FILE *xfp;
  620. {
  621.         long ret;
  622.         ret=fread(buf,size,count,xfp);
  623.         return(ret);
  624. }
  625.  
  626. long __saveds __regargs xfwrite(buf,size,count,fp)
  627. char *buf;
  628. long size,count;
  629. FILE *fp;
  630. {
  631.         long ret;
  632.         ret=fwrite(buf,size,count,fp);
  633.         return(ret);
  634. }
  635.  
  636. long __saveds __regargs xfseek(fp,offset,origin)
  637. FILE *fp;
  638. long offset,origin;
  639. {
  640.         long ret;
  641.         ret=fseek(fp,offset,origin);
  642.         return(ret);
  643. }
  644.  
  645.            /* read from serial port, with timeout */
  646.  
  647. long __saveds __regargs xsread(buff,length,micros)
  648. char *buff;
  649. long length,micros;
  650. {
  651.    long secs = 0L;
  652.    long i = 0L;
  653.    long l;
  654.    ULONG sigs;
  655.  
  656.    if (buff == NULL) return(-1L);
  657.    if (micros) {
  658.       if (micros > 1000000L) {             /* recognize this? */
  659.          secs   = micros / 1000000L;
  660.          micros = micros % 1000000L;
  661.       }
  662.       if (micros<2) micros=3;
  663.       timerreq->tr_node.io_Command=TR_ADDREQUEST;
  664.       timerreq->tr_time.tv_secs=secs;
  665.       timerreq->tr_time.tv_micro=micros;
  666.       serread_req->IOSer.io_Command=CMD_READ;
  667.       serread_req->IOSer.io_Data=(APTR)buff;
  668.       serread_req->IOSer.io_Length=1;
  669.       SendIO((struct IORequest *)serread_req);
  670.       SendIO((struct IORequest *)timerreq);
  671.       while(1)
  672.       {
  673.         sigs=Wait(timermask|serialmask);
  674.         if (CheckIO((struct IORequest *)serread_req)) {
  675.                 serret=(struct IOExtSer *)GetMsg(serial_portr);
  676.                 i++;
  677.                 buff++;
  678.                 if (i==length) {
  679.                         AbortIO((struct IORequest *)timerreq);
  680.                         Wait(timermask);
  681.                         WaitIO((struct IORequest *)timerreq);
  682.                         return(i);
  683.                 }
  684.                 serread_req->IOSer.io_Command=CMD_READ;
  685.                 serread_req->IOSer.io_Data=(APTR)buff;
  686.                 serread_req->IOSer.io_Length=1;
  687.                 SendIO((struct IORequest *)serread_req);
  688.         }
  689.         if (CheckIO((struct IORequest *)timerreq)) {
  690.                 timerreq=(struct IORequest *)GetMsg(timer_port);
  691.                 AbortIO((struct IORequest *)serread_req);
  692.                 WaitIO((struct IORequest *)serread_req);
  693.                 return(i);
  694.         }
  695.       }
  696.     }
  697.     else {
  698.         serread_req->IOSer.io_Command=SDCMD_QUERY;
  699.         DoIO((struct IORequest *)serread_req);
  700.         l=serread_req->IOSer.io_Actual;
  701.         serread_req->IOSer.io_Command=CMD_READ;
  702.         if (l) {
  703.             serread_req->IOSer.io_Data=(APTR)buff;
  704.             serread_req->IOSer.io_Length=l;
  705.             DoIO((struct IORequest *)serread_req);
  706.         }
  707.         return(l);
  708.     }
  709. }
  710.  
  711.  
  712.  
  713. long __saveds __regargs xswrite(buf,size)
  714. char *buf;
  715. long size;
  716. {
  717.         long ret;
  718.         serwrite_req->IOSer.io_Data=(APTR)buf;
  719.         serwrite_req->IOSer.io_Length=size;
  720.         DoIO((struct IORequest *)serwrite_req);
  721.         ret=(ULONG)serwrite_req->IOSer.io_Actual;
  722.         return(ret);
  723. }
  724.  
  725.  
  726. long __saveds __regargs xupdate(ud)   /* display some info about transfer*/
  727. struct XPR_UPDATE *ud;
  728. {
  729.         char out[100];
  730.         char stat[70];
  731.         strcpy(&stat[0],(char *)"   ");
  732.         if (!tit & custom) {
  733.             ShowTitle(screen,TRUE);
  734.             tit=1;
  735.         }
  736.         if (ud->xpru_updatemask & XPRU_PROTOCOL) {
  737.                 printstr(ud->xpru_protocol);
  738.                 printstr("\n");}
  739.         if (ud->xpru_updatemask & XPRU_FILENAME) {
  740.                 printstr(ud->xpru_filename);
  741.                 printstr("\n");}
  742.         if (ud->xpru_updatemask & XPRU_MSG) {
  743.                 printstr(ud->xpru_msg);
  744.                 printstr("\n");}
  745.         if (ud->xpru_updatemask & XPRU_ERRORMSG) {
  746.                 printstr(ud->xpru_errormsg);
  747.                 printstr("\n");}
  748.         if (ud->xpru_updatemask & XPRU_ERRORS) {
  749.                 stci_d(&out[0],ud->xpru_errors);
  750.                 printstr(&out);
  751.                 printstr(" errors\n");}
  752.         if (ud->xpru_updatemask & XPRU_BYTES) {
  753.                 stci_d(&out[0],ud->xpru_bytes);
  754.                 strcpy(&stat[0],&out[0]);
  755.                 strcat(&stat[0],(char *)" bytes ");}
  756.         if (ud->xpru_updatemask & XPRU_BLOCKS) {
  757.                 stci_d(&out[0],ud->xpru_blocks);
  758.                 strcat(&stat[0],&out[0]);
  759.                 strcat(&stat[0],(char *)" blocks ");}
  760.         if (ud->xpru_updatemask & XPRU_DATARATE) {
  761.                 stci_d(&out[0],ud->xpru_datarate);
  762.                 strcat(&stat[0],&out[0]);
  763.                 strcat(&stat[0],(char *)"cps ");}
  764.         if (ud->xpru_updatemask & XPRU_ELAPSEDTIME) {
  765.                 strcat(&stat[0],ud->xpru_elapsedtime);}
  766.         if (ud->xpru_updatemask & XPRU_EXPECTTIME) {
  767.                 strcat(&stat[0],(char *)"/");
  768.                 strcat(&stat[0],ud->xpru_expecttime);}
  769.         if (custom) SetWindowTitles(window,NULL,(char *)&stat);
  770.         else SetWindowTitles(window,(char *)&stat,NULL);
  771.         return(0);
  772. }
  773.  
  774.  
  775. /* the dispatch function for rexx-see arexx disk, minrexx.c example */
  776.  
  777.  
  778. int disp(msg, dat, p)
  779. register struct RexxMsg *msg ;
  780. register struct rexxCommandList *dat ;
  781. char *p ;
  782. {
  783.    replyed=0;
  784.    ((int (*)())(dat->userdata))(msg, p) ;
  785.    if (!replyed) replyRexxCmd(msg, 0L, 0L, NULL) ;
  786.    return(0);
  787. }
  788.  
  789. void rexxquitcom(msg, p)
  790. struct RexxMsg *msg ;
  791. char *p ;
  792. {
  793.    go=0;
  794. }
  795.  
  796. void rexxdownload(msg, p)
  797. struct RexxMsg *msg;
  798. char *p;
  799. {
  800.    ohshit=0;
  801.    dodownload();
  802.    if (ohshit) {
  803.        replyRexxCmd(msg,ohshit,0,NULL);
  804.        replyed=1;
  805.        return;
  806.    }
  807.  
  808. }
  809.  
  810. void rexxupload(msg, p)
  811. struct RexxMsg *msg;
  812. char *p;
  813. {
  814.    ohshit=0;
  815.    doupload();
  816.    if (ohshit) {
  817.        replyRexxCmd(msg,ohshit,0,NULL);
  818.        replyed=1;
  819.        return;
  820.    }
  821.  
  822. }
  823.  
  824.  
  825. void rexxecho(msg, p)
  826. struct RexxMsg *msg;
  827. char *p;
  828. {
  829.    printstr(p);
  830.    printstr("\n");
  831. }
  832.  
  833. void rexxsend(msg,p)
  834. struct RexMsg *msg;
  835. char *p;
  836. {
  837.    int i=0;
  838.    char lineout[80];
  839.    p=stpblk(p);
  840.    while ( (!(*p==0)) & i<78 ) {
  841.         if (*p=='^') {
  842.             *p++;
  843.             lineout[i]=(*p-64);
  844.             i++;
  845.             *p++;
  846.         }
  847.         else {
  848.             lineout[i]=*p;
  849.             i++;
  850.             *p++;
  851.         }
  852.    }
  853.    lineout[i]=0;
  854.    serwrite_req->IOSer.io_Data=(APTR)&lineout;
  855.    serwrite_req->IOSer.io_Length=-1;
  856.    DoIO((struct IORequest *)serwrite_req);
  857. }
  858.  
  859.  
  860.  
  861. void rexxgetstr(msg, p)
  862. struct RexxMsg *msg;
  863. char *p;
  864. {
  865.     char buffer[256];
  866.     long status;
  867.     status = GetString(&buffer, p, window, 50, 255);
  868.     replyRexxCmd(msg, 0, 0, &buffer);
  869.     replyed=1;
  870.     return;
  871.  
  872. }
  873.  
  874.  
  875. void rexxmacro(msg,p)
  876. struct RexxMsg *msg;
  877. char *p;
  878. {
  879.     char num[10],xword[16],xcmd[50];
  880.     p=stpblk(p);
  881.     p=stptok(p,&num,10," ");
  882.     p=stpblk(p);
  883.     p=stptok(p,&xword,16," ");
  884.     p=stpblk(p);
  885.     p=stptok(p,&xcmd,50," ");
  886.     if ( (atoi(&num)<0) | (atoi(&num)>10) ) {
  887.         replyRexxCmd(msg,10,0,NULL);
  888.         replyed=1;
  889.         return;
  890.     }
  891.     strcpy(&words[(((atoi(&num))-1)*50)],&xword[0]);
  892.     strcpy(&cmd[(((atoi(&num))-1)*50)],&xcmd[0]);
  893. }
  894.  
  895.  
  896. void rexxproto(msg,p)
  897. struct RexxMsg *msg;
  898. char *p;
  899. {
  900.     char a[32],b[32];
  901.     p=stpblk(p);
  902.     p=stptok(p,&a[0],32," ");
  903.     p=stpblk(p);
  904.     p=stptok(p,&b[0],32," ");
  905.     ohshit=0;
  906.     doprotocol(&a[0],&b[0]);
  907.     if (ohshit) {
  908.         replyRexxCmd(msg,ohshit,0,NULL);
  909.         replyed=1;
  910.         return;
  911.     }
  912. }
  913.  
  914.  
  915. void rexxserial(msg,p)
  916. struct RexxMsg *msg;
  917. char *p;
  918. {
  919.     int i,e;
  920.     char b[10],s[10];
  921.     p=stpblk(p);
  922.     if (!(*p)) return;
  923.     p=stptok(p,&b,10," ");
  924.     p=stpblk(p);
  925.     p=stptok(p,&s,10," ");
  926.     e=setserial(atol(&b),atol(&s));
  927.     if (e) {
  928.         replyRexxCmd(msg,10,0,NULL);
  929.         replyed=1;
  930.         return;
  931.     }
  932.     ClearMenuStrip(window);
  933.     for (i=1;i<4;i++) m2i[i].Flags &= ~CHECKED;
  934.     if (atol(&b)==1200) i=1;
  935.     else if (atol(&b)==2400) i=2;
  936.         else i=3;
  937.     m2i[i].Flags |= CHECKED;
  938.     for (i=5;i<9;i++) m2i[i].Flags &= ~CHECKED;
  939.     m2i[atoi(&s)+4].Flags |= CHECKED;
  940.     SetMenuStrip(window,(struct Menu *)&mstrip);
  941. }
  942.  
  943. int setserial(baud,set)
  944. long baud;
  945. long set;
  946. {
  947.     int err;
  948.     AbortIO((struct IORequest *)serread_req);
  949.     Wait(serialmask);
  950.     WaitIO((struct IORequest *)serread_req);
  951.     serread_req->IOSer.io_Command=CMD_FLUSH;
  952.     DoIO((struct IORequest *)serread_req);
  953.     serread_req->IOSer.io_Command=CMD_CLEAR;
  954.     DoIO((struct IORequest *)serread_req);
  955.     serread_req->io_Baud=baud;
  956.     if (set==1) {
  957.         serread_req->io_ReadLen=8;
  958.         serread_req->io_WriteLen=8;
  959.         serread_req->io_SerFlags &= ~SERF_PARTY_ON;}
  960.         else if (set==2) {
  961.             serread_req->io_ReadLen=7;
  962.             serread_req->io_WriteLen=7;
  963.             serread_req->io_SerFlags &= ~SERF_PARTY_ON;}
  964.             else if (set==3) {
  965.                 serread_req->io_ReadLen=7;
  966.                 serread_req->io_WriteLen=7;
  967.                 serread_req->io_SerFlags |= SERF_PARTY_ON;
  968.                 serread_req->io_SerFlags &= ~SERF_PARTY_ODD;}
  969.                 else {
  970.                     serread_req->io_ReadLen=7;
  971.                     serread_req->io_WriteLen=7;
  972.                     serread_req->io_SerFlags |= SERF_PARTY_ON;
  973.                     serread_req->io_SerFlags |= SERF_PARTY_ODD;}
  974.         serread_req->IOSer.io_Command=SDCMD_SETPARAMS;
  975.         DoIO((struct IORequest *)serread_req);
  976.         err=serread_req->IOSer.io_Error;
  977.         serread_req->IOSer.io_Command=CMD_READ;
  978.         serread_req->IOSer.io_Data=(APTR)&serbuf[0];
  979.         serread_req->IOSer.io_Length=1;
  980.         SendIO((struct IORequest *)serread_req);
  981.         return(err);
  982. }
  983.  
  984.  
  985. void rexxcapon(msg,p)
  986. struct RexxMsg *msg;
  987. char *p;
  988. {
  989.     ohshit=0;
  990.     p=stpblk(p);
  991.     opencapture(p);
  992.     if (ohshit) {
  993.         replyRexxCmd(msg,ohshit,0,NULL);
  994.         replyed=1;
  995.         return;
  996.     }
  997. }
  998.  
  999. void rexxcapoff(msg,p)
  1000. struct RexxMsg *msg;
  1001. char *p;
  1002. {
  1003.     closecapture();
  1004. }
  1005.  
  1006. void rexxwaitstr(msg,p)   /*apparently this doesn't work to well at */
  1007. struct RexxMsg *msg;      /* 2400. sorry */
  1008. char *p;
  1009. {
  1010.     char dlay[10];
  1011.     ULONG sig;
  1012.     int actu,i,d;
  1013.     p=stpblk(p);
  1014.     p=stptok(p,&matchstr[0],10," ");
  1015.     p=stpblk(p);
  1016.     p=stptok(p,&dlay[0],10," ");
  1017.     d=atoi(&dlay[0]);
  1018.     timerreq->tr_node.io_Command=TR_ADDREQUEST;
  1019.     timerreq->tr_time.tv_secs=d;
  1020.     timerreq->tr_time.tv_micro=0;
  1021.     match=1;
  1022.     matched=0;
  1023.     matchptr=&matchstr[0];
  1024.     SendIO((struct IORequest *)timerreq);
  1025.     while (!matched) {
  1026.         sig=Wait(serialmask|windowmask|timermask);
  1027.         if (sig & windowmask) dowindow();
  1028.         if (CheckIO((struct IORequest *)timerreq)) {
  1029.             timerreq=(struct IORequest *)GetMsg(timer_port);
  1030.             replyRexxCmd(msg,15,0,NULL);
  1031.             replyed=1;
  1032.             return;
  1033.         }
  1034.         if (CheckIO((struct IORequest *)serread_req)) {
  1035.             actu=readserial();
  1036.             for (i=0;i<actu;i++) {
  1037.                 if (serbuf[i]==*matchptr) {
  1038.                     matchptr++;
  1039.                     if (!(*matchptr)) {
  1040.                         matched=1;
  1041.                         matchptr=&matchstr[0];
  1042.                         goto here;
  1043.                     }
  1044.                 }
  1045.                 else matchptr=&matchstr[0];
  1046.             }
  1047. here:
  1048.             if (actu>0) {
  1049.                 for (i=0;i<actu;i++) serbuf[i] &= 0x7f;
  1050.                 conwrite_req->io_Data=(APTR)&serbuf[0];
  1051.                 conwrite_req->io_Length=actu;
  1052.                 DoIO((struct IORequest *)conwrite_req);
  1053.             }
  1054.             serread_req->IOSer.io_Data=(APTR)&serbuf[0];
  1055.             serread_req->IOSer.io_Length=1;
  1056.             SendIO((struct IORequest *)serread_req);
  1057.         }
  1058.     }
  1059.     AbortIO((struct IORequest *)timerreq);
  1060.     Wait(timermask);
  1061.     WaitIO((struct IORequest *)timerreq);
  1062. }
  1063.  
  1064. void rexxpause(msg,p)
  1065. struct RexxMsg *msg;
  1066. char *p;
  1067. {
  1068.     int i,d,actu;
  1069.     char dlay[10];
  1070.     p=stpblk(p);
  1071.     p=stptok(p,&dlay[0],10," ");
  1072.     d=atoi(&dlay[0]);
  1073.     timerreq->tr_node.io_Command=TR_ADDREQUEST;
  1074.     timerreq->tr_time.tv_secs=d;
  1075.     timerreq->tr_time.tv_micro=0;
  1076.     SendIO((struct IORequest *)timerreq);
  1077.     while(1) {
  1078.         Wait(timermask|serialmask);
  1079.         if (CheckIO((struct IORequest *)serread_req)) {
  1080.             actu=readserial();
  1081.             if (actu>0) {
  1082.                 for (i=0;i<actu;i++) {
  1083.                     serbuf[i] = serbuf[i] & 0x7f;
  1084.                     if (serbuf[i]<32) {
  1085.                         switch (serbuf[i])
  1086.                         {
  1087.                             case 7:      /* where have i seen this before */
  1088.                             case 8:
  1089.                             case 10:
  1090.                             case 12:
  1091.                             case 13:
  1092.                             case 27:
  1093.                                 break;
  1094.                             default:
  1095.                                 serbuf[i]=32;
  1096.                         }
  1097.                     }
  1098.                 }
  1099.                 conwrite_req->io_Data=(APTR)&serbuf[0];
  1100.                 conwrite_req->io_Length=actu;
  1101.                 DoIO((struct IORequest *)conwrite_req);
  1102.             }
  1103.             serread_req->IOSer.io_Data=(APTR)&serbuf[0];
  1104.             serread_req->IOSer.io_Length=1;
  1105.             SendIO((struct IORequest *)serread_req);
  1106.         }
  1107.         if (CheckIO((struct IORequest *)timerreq)) {
  1108.             timerreq=(struct IORequest *)GetMsg(timer_port);
  1109.             return;
  1110.         }
  1111.     }
  1112. }
  1113.  
  1114.  
  1115.  
  1116.