home *** CD-ROM | disk | FTP | other *** search
/ Club Amiga de Montreal - CAM / CAM_CD_1.iso / files / 428.lha / SampleScanner / src / SampleScanner.c < prev   
Encoding:
C/C++ Source or Header  |  1990-10-02  |  19.0 KB  |  616 lines
  1. #include <exec/types.h>
  2. #include <exec/memory.h>
  3. #include <exec/devices.h>
  4. #include <intuition/intuition.h>
  5. #include <intuition/intuitionbase.h>
  6. #include <devices/audio.h>
  7. #include <devices/trackdisk.h>
  8. #include <libraries/dos.h>
  9. #include <libraries/dosextens.h>
  10. #include <stdio.h>
  11. #include "rawkey.h"
  12. #include "menus.h"
  13.  
  14. extern struct DosLibrary *DOSBase;
  15.  
  16. char IDstring[50] = {"Samplescanner by Steven Lagerweij 160390"};
  17.                                                       /*ddmmyy*/
  18. struct IntuitionBase    *IntuitionBase;
  19. struct GfxBase          *GfxBase;
  20. struct Window           *win,*sswin,*savewin;
  21. struct IntuiMessage     *message;
  22. struct MsgPort          *diskport;
  23. struct IOExtTD          *diskreq;
  24. extern struct MsgPort   *CreatePort();
  25. extern struct IORequest *CreateExtIO();
  26. struct MsgPort          *AudioPort;
  27. struct IOAudio           Audio;
  28.  
  29. char *LeftMouse = (char *) 0xBFE001;
  30. char Attached[128];
  31. UBYTE Channels[] = { 0x0F };
  32. int AudioDev = NULL;
  33. long to = 0,from = 88;
  34. char file[64];
  35. char dir[64] = {"RAM:"};
  36. struct Gadget *GadgetPtr;
  37. struct MenuItem *Item;
  38. ULONG MessageClass;
  39. USHORT code,MenuItem, GadgetID, block = 0;
  40.  
  41. long volume = 64, period = 428, drive = 1,val,cnt;
  42.  
  43. BYTE *diskbuffer, num;
  44.  
  45. struct Message *GetMsg();
  46.  
  47. VOID _main()
  48. {
  49.     if((FindUnit("DF1:"))) ThItem2.Flags |= ITEMENABLED;
  50.     if((FindUnit("DF2:"))) ThItem3.Flags |= ITEMENABLED;
  51.     if((FindUnit("DF3:"))) ThItem4.Flags |= ITEMENABLED;
  52.     ThItem1.Flags |= CHECKED; drive = 0;
  53.     OpenAll();
  54.     SetMenuStrip(win,&FirstMenu);
  55.     SetPropTo(block); BufSize(block/88); Grafiek(0);
  56.     for(;;)
  57.        {
  58.         if ((message = (struct IntuiMessage *)
  59.             GetMsg(win->UserPort)) == NULL)
  60.               {
  61.                 Wait(1<<win->UserPort->mp_SigBit);
  62.                 continue;
  63.               }
  64.         MessageClass = message->Class;
  65.         code      = message->Code;
  66.         ReplyMsg(message);
  67.  
  68.         if(MessageClass != RAWKEY)
  69.                 SetWindowTitles(win,"Sample scanner",NULL);
  70.  
  71.         switch (MessageClass)
  72.           {
  73.             case CLOSEWINDOW : CloseAll(); break;
  74.             case MENUPICK    : while(code != MENUNULL)
  75.                                  {
  76.                                     MenuItem = ITEMNUM(code);
  77.                                     Item = (struct MenuItem *)
  78.                                            ItemAddress(&FirstMenu, code);
  79.                                     if(WhichMenu(code)) CloseAll();
  80.                                     code = Item->NextSelect;
  81.                                  }
  82.                                break;
  83.             case GADGETUP    : BufSize(ProperInfo.HorizPot/PROPSHIFT);
  84.                                val = ReadBlock(88);
  85.                                if(val != 0)
  86.                                 {
  87.                                  if(val > 0)
  88.                                     SetWindowTitles(win,"Error reading disk",NULL);
  89.                                  else {
  90.                                    switch(val) {
  91.                                      case NODISK  : SetWindowTitles(win,"No disk in drive",NULL); break;
  92.                                      case OPENFAIL: SetWindowTitles(win,"Couldn't open trackdisk",NULL); break;
  93.                                      default      : SetWindowTitles(win,"Unspecified error",NULL); break;
  94.                                     }
  95.                                   }
  96.                                  break;
  97.                                 }
  98.                                PlayBlock(88);
  99.                                break;
  100.          }
  101.        }
  102. }
  103.  
  104. BufSize(num)
  105. USHORT num;
  106. {
  107. char tmp[50];
  108.     block = num*88;
  109.     if(block > 1672) block = 1672;
  110.     SetAPen(win->RPort,1);
  111.     sprintf(&tmp[0],"Block: %-4d",block);
  112.     Move(win->RPort,125,18);
  113.     Text(win->RPort,&tmp[0],strlen(&tmp[0]));
  114.     return(0);
  115. }
  116.  
  117. SetPropTo(num)
  118. USHORT num;
  119. {
  120.     ModifyProp(&ProperGadget,
  121.                 win,NULL,
  122.                 ProperInfo.Flags,
  123.                 ((num/88) * PROPSHIFT), 0,
  124.                 ProperInfo.HorizBody,0 );
  125.     return(0);
  126. }
  127.  
  128.  
  129. OpenAll()
  130. {
  131. IntuitionBase = (struct IntuitionBase *)OpenLibrary("intuition.library",0);
  132. GfxBase       = (struct GfxBase *)      OpenLibrary("graphics.library",0);
  133. if(!(win = (struct Window *)OpenWindow(&Newwin)))
  134.  { DisplayBeep(0); CloseAll(); }
  135. if(!(diskbuffer = (BYTE *)AllocMem(88*512,MEMF_CLEAR | MEMF_CHIP)))
  136.  { DisplayBeep(0); Delay(25); DisplayBeep(0); CloseAll(); }
  137. return(0);
  138. }
  139.  
  140. CloseAll()
  141. {
  142.     if(diskbuffer)    FreeMem(diskbuffer,88*512);
  143.     if(win)           { ClearMenuStrip(win); CloseWindow(win); }
  144.     if(GfxBase)       CloseLibrary(GfxBase);
  145.     if(IntuitionBase) CloseLibrary(IntuitionBase);
  146. exit(0); return(0);
  147. }
  148.  
  149. struct IORequest *CreateExtIO(ioReplyPort,size) /* create extended I/O */
  150.       struct MsgPort *ioReplyPort;
  151.       LONG size;
  152. {
  153.       struct IORequest *ioReq;
  154.  
  155.    if(ioReplyPort == 0)
  156.       return((struct IORequest *) 0);
  157.  
  158.    ioReq = (struct IORequest *)AllocMem (size,MEMF_CLEAR | MEMF_PUBLIC);
  159.    if(ioReq==0)
  160.       return((struct IORequest *) 0);
  161.    ioReq->io_Message.mn_Node.ln_Type = NT_MESSAGE;
  162.    ioReq->io_Message.mn_Node.ln_Pri = 0;
  163.    ioReq->io_Message.mn_ReplyPort = ioReplyPort;
  164.    return(ioReq);
  165. }
  166.  
  167. DeleteExtIO(ioExt,size) /* Remove Extendend I/O */
  168.    struct IORequest *ioExt;
  169.    LONG size;
  170. {
  171.    ioExt->io_Message.mn_Node.ln_Type = 0xff;
  172.    ioExt->io_Device = (struct Device *) -1;
  173.    ioExt->io_Unit = (struct Unit *) -1;
  174.    FreeMem(ioExt,size);
  175. return(0);
  176. }
  177.  
  178.  
  179. ReadBlock(len)
  180. short len;
  181. {
  182. short readerr,ret = -1,dev = TRUE;
  183.  
  184.    if((block < 0) || (block > 1759)) return(OUTOFRANGE);
  185.    if(!(diskport = CreatePort(0,0))) return(ret);
  186.  
  187.    if(!(diskreq = (struct IOExtTD *)
  188.         CreateExtIO(diskport,sizeof(struct IOExtTD)))) goto quit;
  189.  
  190.    if((dev = OpenDevice(TD_NAME,drive,diskreq,0))) goto quit;
  191.  
  192.    diskreq->iotd_Req.io_Command = TD_CHANGESTATE;
  193.    DoIO(diskreq);
  194.    if(diskreq->iotd_Req.io_Actual != 0) { ret = NODISK; goto quit; }
  195.  
  196.    diskreq->iotd_Req.io_Length  = 1;
  197.    diskreq->iotd_Req.io_Command = TD_MOTOR;
  198.    DoIO(diskreq);
  199.  
  200.  
  201.    diskreq->iotd_Req.io_Length  = len*512;
  202.    diskreq->iotd_Req.io_Data    = (APTR)diskbuffer;
  203.    diskreq->iotd_Req.io_Command = CMD_READ;
  204.    diskreq->iotd_Req.io_Offset  = block*512;
  205.    DoIO(diskreq);
  206.  
  207.    readerr=diskreq->iotd_Req.io_Error;
  208.  
  209.    diskreq->iotd_Req.io_Length  = 0;
  210.    diskreq->iotd_Req.io_Command = TD_MOTOR;
  211.    DoIO(diskreq);
  212.  
  213.    if(readerr != 0) ret = readerr;
  214.    else             ret = 0;
  215. quit:
  216.    if(!dev)     CloseDevice(diskreq);
  217.    if(diskreq)  DeleteExtIO(diskreq,sizeof(struct IOExtTD));
  218.    if(diskport) DeletePort(diskport);
  219. return(ret);
  220. }
  221.  
  222. PlayBlock(len)
  223. short len;
  224. {
  225.     AudioDev = NULL;
  226.     AudioPort = 0;
  227.     if(!(AudioPort = CreatePort("Audioport scanner"))) goto quit;
  228.     Audio.ioa_Request.io_Message.mn_Node.ln_Pri = 128;
  229.     Audio.ioa_Request.io_Message.mn_ReplyPort   = AudioPort;
  230.     Audio.ioa_Request.io_Command                = ADCMD_ALLOCATE;
  231.     Audio.ioa_Data                              = Channels;
  232.     Audio.ioa_Length                            = (long)sizeof(Channels);
  233.  
  234.     AudioDev = OpenDevice(AUDIONAME,0,&Audio,0);
  235.     if(AudioDev != NULL) goto quit;
  236. ag:
  237.     Audio.ioa_Request.io_Command = CMD_WRITE;
  238.     Audio.ioa_Request.io_Flags   = ADIOF_PERVOL | ADIOF_SYNCCYCLE;
  239.     Audio.ioa_Request.io_Unit    = (struct Unit *)1;
  240.     Audio.ioa_Data               = (UBYTE *)diskbuffer;
  241.     Audio.ioa_Length             = len*512;
  242.     Audio.ioa_Period             = period;
  243.     Audio.ioa_Volume             = volume;
  244.     Audio.ioa_Cycles             = 1;
  245.  
  246.     BeginIO(&Audio);
  247.     if(CheckIO(&Audio))
  248.       {
  249.         WaitIO(&Audio);
  250.         goto ag;
  251.       }
  252.     Grafiek(1);
  253.     WaitIO(&Audio);
  254. quit:
  255.     if(!AudioDev)   CloseDevice(&Audio);
  256.     if(AudioPort)   DeletePort(AudioPort);
  257. return(0);
  258. }
  259.  
  260.  
  261. Grafiek(from)
  262. int from;
  263. {
  264.     long ybase = 100,x = 44,cnt,bufpos = 0;
  265.     LONG sum,sumlen;
  266.  
  267.     SetAPen(win->RPort,0);
  268.     RectFill(win->RPort,4,(ybase-65),560,(ybase+85));
  269.     ShowNums(ybase);
  270.  
  271.     sumlen = (512*88)/512; /* Haha! */
  272.  
  273.     SetAPen(win->RPort,3);
  274.     Move(win->RPort,x,ybase);
  275.     for(x=44;x<556;x++)
  276.       {
  277.         sum = 0;
  278.         for(cnt=0;cnt<sumlen;cnt++)
  279.            {
  280.              if(((*LeftMouse & 0x40) != 0x40) &&
  281.                (IntuitionBase->ActiveWindow == win))
  282.                {
  283.                  if(from) AbortIO(&Audio);
  284.                  goto quit;
  285.                }
  286.              sum += diskbuffer[bufpos];
  287.              bufpos++;
  288.            }
  289.         sum = (sum / sumlen)/2; /* (average)/2 (/2 = only 128 pixels available)*/
  290.         Draw(win->RPort,x,ybase+sum);
  291.       }
  292. quit:
  293.     return(0);
  294. }
  295.  
  296.  
  297. ShowNums(ybase)
  298. long ybase;
  299. {
  300. long cnt,tblk = block;
  301. char tmp[6];
  302.     SetAPen(win->RPort,1);
  303.     Move(win->RPort,2,ybase+3);  Text(win->RPort,"   0",4);
  304.     Move(win->RPort,2,ybase-61); Text(win->RPort,"-128",4);
  305.     Move(win->RPort,2,ybase+67); Text(win->RPort,"+128",4);
  306.     SetAPen(win->RPort,2);
  307.     Move(win->RPort,36,ybase-64);  Draw(win->RPort,36,ybase+64);
  308.     Move(win->RPort,44,ybase+70);  Draw(win->RPort,555,ybase+70);
  309.     SetAPen(win->RPort,1);
  310.     Move(win->RPort,36,ybase);     Draw(win->RPort,40,ybase);
  311.     Move(win->RPort,36,ybase-64);  Draw(win->RPort,40,ybase-64);
  312.     Move(win->RPort,36,ybase+64);  Draw(win->RPort,40,ybase+64);
  313.     for(cnt=44;cnt<557;cnt+=64)
  314.       {
  315.         Move(win->RPort,cnt,ybase+67);
  316.         Draw(win->RPort,cnt,ybase+73);
  317.         Move(win->RPort,cnt-3,ybase+83);
  318.         sprintf(&tmp[0],"%-4d",tblk);
  319.         Text(win->RPort,&tmp[0],4);
  320.         tblk += 11;
  321.       }
  322.  
  323.  
  324. return(0);
  325. }
  326.  
  327. WhichMenu(wcode)
  328. USHORT wcode;
  329. {
  330.    USHORT whichMenu, whichItem, whichSubItem;
  331.  
  332.    whichMenu     = MENUNUM(wcode);
  333.    whichItem     = ITEMNUM(wcode);
  334.    whichSubItem  = SUBNUM(wcode);
  335.  
  336.    switch(whichMenu)
  337.    {
  338.       case 0 : /* Options */
  339.                switch(whichItem)
  340.                  {
  341.                    case 1 : return(TRUE);
  342.                    case 0 : BlocksToFile(); break;
  343.                  }
  344.                break;
  345.       case 1 : /* Play */
  346.                switch(whichItem)
  347.                  {
  348.                    case 3 : FilterToggle(); break;
  349.                    case 2 : SampleSets(); break;
  350.                    case 1 :
  351.                             for(block=block;block<1759;block+=88)
  352.                              {
  353.                                BufSize(block/88);
  354.                                SetPropTo(block);
  355.                                if(((*LeftMouse & 0x40) != 0x40) &&
  356.                                  (IntuitionBase->ActiveWindow == win)) goto quit;
  357.                                val = ReadBlock(88);
  358.                                if(val != 0)
  359.                                 {
  360.                                  if(val > 0)
  361.                                     SetWindowTitles(win,"Error reading disk",NULL);
  362.                                  else {
  363.                                    switch(val) {
  364.                                      case NODISK  : SetWindowTitles(win,"No disk in drive",NULL); break;
  365.                                      case OPENFAIL: SetWindowTitles(win,"Couldn't open trackdisk",NULL); break;
  366.                                      default      : SetWindowTitles(win,"Unspecified error",NULL); break;
  367.                                     }
  368.                                   }
  369.                                  break;
  370.                                 }
  371.                                PlayBlock(88);
  372.                              }
  373.                             block = 0;
  374.                             BufSize(0);
  375.                             SetPropTo(block);
  376.                             break;
  377.                    case 0 : PlayBlock(88); break;
  378.                  }
  379.                break;
  380.       case 2 : /* Options */
  381.                switch(whichItem)
  382.                  {
  383.                    case 3 : ThItem4.Flags |= CHECKED; drive = 3; break;
  384.                    case 2 : ThItem3.Flags |= CHECKED; drive = 2; break;
  385.                    case 1 : ThItem2.Flags |= CHECKED; drive = 1; break;
  386.                    case 0 : ThItem1.Flags |= CHECKED; drive = 0; break;
  387.                  }
  388.                break;
  389.    }
  390. quit:
  391.    return(0);
  392. }
  393.  
  394.  
  395. SampleSets()
  396. {
  397. char tmp[10];
  398.     sswin = NULL;
  399.     if(!(sswin = (struct Window *)OpenWindow(&newsswin)))
  400.       { SetWindowTitles(win,"Not enough memory for window",NULL); return(FALSE); }
  401.     ModifyProp(&VolumeGadget, sswin,NULL, VolumeInfo.Flags,
  402.                 (MAXBODY/64) * volume, 0, VolumeInfo.HorizBody,0 );
  403.     ModifyProp(&PeriodGadget, sswin,NULL, PeriodInfo.Flags,
  404.                 ((MAXBODY/64) * ((period-128)/10)), 0, PeriodInfo.HorizBody,0 );
  405.     for(;;)
  406.       {
  407.         SetAPen(sswin->RPort,1);
  408.         sprintf(&tmp[0],"%-2ld",volume);
  409.         Move(sswin->RPort,22,26);  Text(sswin->RPort,"Volume",6);
  410.         Move(sswin->RPort,145,26); Text(sswin->RPort,&tmp[0],2);
  411.  
  412.         sprintf(&tmp[0],"%-4ld",period);
  413.         Move(sswin->RPort,22,38); Text(sswin->RPort,"Period",6);
  414.         Move(sswin->RPort,145,38); Text(sswin->RPort,&tmp[0],4);
  415.  
  416.         if(!(message = (struct IntuiMessage *)GetMsg(sswin->UserPort)))
  417.           {
  418.             Wait(1<<sswin->UserPort->mp_SigBit);
  419.             continue;
  420.           }
  421.         MessageClass = message->Class;
  422.         code         = message->Code;
  423.         GadgetPtr    = (struct Gadget *) message->IAddress;
  424.         GadgetID     = GadgetPtr->GadgetID;
  425.         ReplyMsg(message);
  426.  
  427.  
  428.         switch (MessageClass)
  429.           {
  430.             case CLOSEWINDOW : goto quit;
  431.             case GADGETUP    :
  432.               switch(GadgetID)
  433.                 {
  434.                   case 1 :volume = (VolumeInfo.HorizPot/(MAXBODY/64));
  435.                           break;
  436.                   case 2 :period = 128+((PeriodInfo.HorizPot/(MAXBODY/64))*10);
  437.                           break;
  438.                 }
  439.           }
  440.       }
  441. quit:
  442.     if(sswin) CloseWindow(sswin);
  443.     return(TRUE);
  444. }
  445.  
  446.  
  447.  
  448. BlocksToFile()
  449. {
  450. char tmp[28];
  451. long ret;
  452.  
  453.     savewin = NULL;
  454.     if(!(savewin = (struct Window *)OpenWindow(&newsavewin)))
  455.       { SetWindowTitles(win,"Not enough memory for window",NULL); return(FALSE); }
  456.     ActivateGadget(&FromGadget,savewin,NULL);
  457.     for(;;)
  458.       {
  459.         SetAPen(savewin->RPort,3);
  460.         sprintf(&tmp[0],"From drive : DF%ld",drive);
  461.         Move(savewin->RPort,10,18);
  462.         Text(savewin->RPort,&tmp[0],16);
  463.         Move(savewin->RPort,10,28);
  464.         Text(savewin->RPort,"From block :",12);
  465.         Move(savewin->RPort,10,38);
  466.         Text(savewin->RPort,"To block   :",12);
  467.         Move(savewin->RPort,10,48);
  468.         Text(savewin->RPort,"To file    :",12);
  469.         if(!(message = (struct IntuiMessage *)GetMsg(savewin->UserPort)))
  470.           {
  471.             Wait(1<<savewin->UserPort->mp_SigBit);
  472.             continue;
  473.           }
  474.         MessageClass = message->Class;
  475.         code         = message->Code;
  476.         GadgetPtr    = (struct Gadget *) message->IAddress;
  477.         GadgetID     = GadgetPtr->GadgetID;
  478.         ReplyMsg(message);
  479.  
  480.         switch (MessageClass)
  481.           {
  482.             case CLOSEWINDOW : goto quit;
  483.             case GADGETUP    :
  484.                 switch(GadgetID)
  485.                   {
  486. /*filename String*/ case 1 : ActivateGadget(&FromGadget,savewin,NULL); break;
  487. /*to gadget */      case 2 : to = atoi(ToBuf);
  488.                              if((to < 0) || (to > 1759))
  489.                                {
  490.                                  to = 1; ToBuf[0] = '1'; ToBuf[1] = '\0';
  491.                                  RefreshGadgets(&ToGadget,savewin,NULL);
  492.                                }
  493.                              ActivateGadget(&StringGadget,savewin,NULL); break;
  494. /* from gadget */   case 3 : from = atoi(Frombuf);
  495.                              if((from < 0) || (from > 1759))
  496.                                {
  497.                                  from = 0; Frombuf[0] = '0'; Frombuf[1] = '\0';
  498.                                  RefreshGadgets(&FromGadget,savewin,NULL);
  499.                                }
  500.                              ActivateGadget(&ToGadget,savewin,NULL); break;
  501.                     case 4 :
  502.                              if(to <= from)
  503.                                {
  504.                                  SetWindowTitles(savewin,"To must be > from",NULL);
  505.                                  break;
  506.                                }
  507.                              if(SaveToFile()) goto quit;
  508.                              break;
  509.                     case 5 :
  510.                              ret = arpreq("GET FILENAME", file, dir,NULL);
  511.                              if((ret != 0) && (file[0] != '\0'))
  512.                                {
  513.                                  Koppel(&dir[0],&file[0]);
  514.                                  sprintf(&StringBuffer[0],"%s",&Attached[0]);
  515.                                  RefreshGadgets(&StringGadget,savewin,NULL);
  516.                                }
  517.                              ActivateGadget(&FromGadget,savewin,NULL);
  518.                              break;
  519.  
  520.                   }
  521.             break;
  522.           }
  523.       }
  524. quit:
  525.     if(savewin) CloseWindow(savewin);
  526.     return(TRUE);
  527. }
  528.  
  529. SaveToFile()
  530. {
  531.     long remblk = block,numblk,loop = TRUE,realnum;
  532.     char temp[100],*Fileptr = NULL;
  533.  
  534.     if(!(Fileptr = (char *)Open(&StringBuffer[0],1006)))
  535.       { SetWindowTitles(savewin,"Couldn't open file",NULL); return(FALSE); }
  536.  
  537.     numblk = to-from;
  538.     block = from;
  539.     while(loop)
  540.       {
  541.         if(numblk >= 88) realnum = 88;
  542.         else realnum = numblk;
  543.  
  544.         sprintf(&temp[0],"Reading... %-4ld blks     ",realnum);
  545.         Move(savewin->RPort,10,60);
  546.         Text(savewin->RPort,&temp[0],strlen(&temp[0]));
  547.         val = ReadBlock(realnum);
  548.         if(val != 0)
  549.          {
  550.          if(val > 0)
  551.              SetWindowTitles(win,"Error reading disk",NULL);
  552.          else {
  553.             switch(val) {
  554.              case NODISK   : SetWindowTitles(win,"No disk in drive",NULL); break;
  555.               case OPENFAIL: SetWindowTitles(win,"Couldn't open trackdisk",NULL); break;
  556.               default      : SetWindowTitles(win,"Unspecified error",NULL); break;
  557.              }
  558.            }
  559.            goto quit;
  560.          }
  561.         sprintf(&temp[0],"Writing... %-4ld blks left",numblk);
  562.         Move(savewin->RPort,10,60);
  563.         Text(savewin->RPort,&temp[0],strlen(&temp[0]));
  564.         if(Write(Fileptr,diskbuffer,realnum*512) != realnum*512)
  565.          {
  566.            SetWindowTitles(win,"Error while writing !",NULL);
  567.            Delay(25);
  568.            loop = FALSE;
  569.          }
  570.         numblk -= realnum; block += realnum;
  571.         if(numblk < 1) loop = FALSE;
  572.       }
  573. quit:
  574.     if(Fileptr) Close(Fileptr);
  575.  
  576. block = remblk;
  577. return(TRUE);
  578. }
  579.  
  580. FindUnit(devname)
  581. char *devname;
  582. {
  583. struct   DeviceList    *zoekdev;
  584. char isithim[50];
  585. zoekdev = (struct DeviceList *) BADDR(((struct DosInfo *)
  586.        BADDR(((struct RootNode *) (DOSBase->dl_Root))->rn_Info))->di_DevInfo);
  587.  
  588. while(zoekdev != 0)
  589.     {
  590.         sprintf(&isithim[0],"%s:",BADDR(zoekdev->dl_Name)+1);
  591.         if((zoekdev->dl_Type == DLT_DEVICE) &&
  592.            (stcpma(devname,&isithim[0])))
  593.             return(TRUE);
  594.         zoekdev = (struct DeviceList *)BADDR(zoekdev->dl_Next);
  595.     }
  596. return(FALSE);
  597. }
  598.  
  599.  
  600. Koppel(dirname,filename) /* Fix arpreq result */
  601. char dirname[64],filename[64];
  602. {
  603.     if(dirname[0] == '\0')
  604.        { sprintf(&Attached[0],"%s",&filename[0]); return(0); };
  605.  
  606.     if((dirname[strlen(&dirname[0])-1] != ':') &&
  607.        (dirname[strlen(&dirname[0])-1] != '/'))
  608.        sprintf(&Attached[0],"%s/%s",&dirname[0],&filename[0]);
  609.     else                    /* ^ !!!! */
  610.        sprintf(&Attached[0],"%s%s",&dirname[0],&filename[0]);
  611.  
  612. return(0);
  613. }
  614.  
  615.  
  616.