home *** CD-ROM | disk | FTP | other *** search
/ Amiga Format CD 2 / amigaformatcd02.iso / pd / utilities / tinymeter / source / tinymeter_main / volumes.c < prev   
Encoding:
C/C++ Source or Header  |  1996-05-20  |  4.4 KB  |  184 lines
  1. #include <exec/types.h>
  2. #include <exec/memory.h>
  3. #include <dos/dos.h>
  4. #include <dos/dosextens.h>
  5. #include <dos/dostags.h>
  6. #include <dos/notify.h>
  7. #include <string.h>
  8. #include <libraries/WBStart.h>
  9. #include <workbench/startup.h>
  10. #include <workbench/workbench.h>
  11. #include <intuition/classes.h>
  12. #include <clib/macros.h>
  13. #include "gaugeclass.h"
  14. #include "tinymeter.h"
  15. #include "launchclass.h"
  16.  
  17. BOOL CopyPathList(struct PathList **pla, struct PathList **plc,struct PathList *oldpl)
  18. {
  19.     struct PathList *pl1=oldpl,*pl2=*plc,*pl3=NULL;
  20.     while (pl1)
  21.     {
  22.     if (!(pl3 || (pl3=(struct PathList *)pAllocVec(sizeof(struct PathList))))) return(FALSE);
  23.     if (pl3->PathLock=DupLock(pl1->PathLock))
  24.     {
  25.         if (*pla) pl2->NextPath=MKBADDR(pl3);
  26.         else *pla=pl3;
  27.         pl2=pl3;
  28.         pl3=NULL;
  29.     }
  30.     pl1=BADDR(pl1->NextPath);
  31.     }
  32.     if (pl3) pFreeVec(pl3);
  33.     *plc=pl2;
  34.     return(TRUE);
  35. }
  36.  
  37. void FreePathList(struct PathList *pla)
  38. {
  39.     if (pla)
  40.     {
  41.     struct PathList *pl1=pla,*pl2;
  42.     do
  43.     {
  44.         pl2=BADDR(pl1->NextPath);
  45.         UnLock(pl1->PathLock);
  46.         pFreeVec(pl1);
  47.     }
  48.     while (pl1=pl2);
  49.     }
  50. }
  51.  
  52. BOOL InitWorkbenchPath(struct tm_data *data)
  53. {
  54.     struct Process *wbproc=(struct Process *)FindTask("Workbench");
  55.     if(!wbproc)     wbproc=(struct Process *)FindTask("DirectoryOpus");
  56.  
  57.     if (wbproc && (wbproc->pr_Task.tc_Node.ln_Type==NT_PROCESS))
  58.     {
  59.     struct CommandLineInterface *wbcli=BADDR(wbproc->pr_CLI);
  60.     if (wbcli)
  61.     {
  62.         struct PathList *dummy;
  63.         if (CopyPathList(&data->GlobalPath,&dummy,(struct PathList *) BADDR(wbcli->cli_CommandDir)));
  64.     }
  65.     }
  66.     return(TRUE); 
  67. }
  68.  
  69. FreeWorkbenchPath(struct tm_data *data)
  70. {
  71.     FreePathList(data->GlobalPath);
  72. }
  73.  
  74. RunCLI(struct lau_entry *entry, struct tm_data *data, struct WBArg *wbarg, ULONG numarg)
  75. {
  76.     BOOL            rc=TRUE;
  77.     char            *def =0;
  78.     char            *argstr=0L;
  79.     BPTR            newcd,
  80.             ofh,
  81.             oldcd,
  82.             ifh;
  83.     struct MsgPort  *newct=NULL;
  84.  
  85.     if(wbarg)
  86.     {
  87.     if(argstr=(char *)pAllocVec(2048L))
  88.     {
  89.         char    *actpos;
  90.         int     i;
  91.  
  92.         strcpy(argstr,entry->lau_cmd);
  93.         strcat(argstr," ");
  94.         actpos=&argstr[strlen(argstr)];
  95.         for(i=0;i<numarg;i++)
  96.         {
  97.         NameFromLock(((struct WBArg *)&wbarg[i])->wa_Lock,actpos,512L);
  98.         AddPart(actpos,((struct WBArg *)&wbarg[i])->wa_Name,512L);
  99.         strcat(actpos," ");
  100.         actpos=&argstr[strlen(argstr)];
  101.         }
  102.     }
  103.     }
  104.     if(entry->lau_pth)  newcd=Lock(entry->lau_pth,SHARED_LOCK);
  105.     else                newcd=0L;
  106.     if(!newcd)
  107.     {
  108.     char *foo;
  109.     int i;
  110.     foo=(char *)FilePart(entry->lau_cmd);
  111.     if(def=(char *)pAllocVec(foo-entry->lau_cmd+2))
  112.     {
  113.         for(i=0;i<(foo-entry->lau_cmd);i++) def[i]=entry->lau_cmd[i];
  114.         def[i]=0;
  115.         newcd=Lock(def,SHARED_LOCK);
  116.     }
  117.     }
  118.     if(!(ofh=Open(entry->lau_out, MODE_NEWFILE)))
  119.      ofh=Open("NIL:",         MODE_NEWFILE);
  120.     if(ofh)
  121.     {
  122.     if (IsInteractive(ofh))
  123.     {
  124.         struct MsgPort *oldct;
  125.         newct=((struct FileHandle *) BADDR(ofh))->fh_Type;
  126.         oldct=(struct MsgPort *)SetConsoleTask(newct);
  127.         ifh=Open("CONSOLE:",MODE_OLDFILE);
  128.         SetConsoleTask(oldct);
  129.     }
  130.     else ifh=Open("NIL:",MODE_OLDFILE);
  131.     if (ifh)
  132.     {
  133.         struct PathList *pla=NULL,*plc=NULL;
  134.         oldcd=CurrentDir(newcd);
  135.         if(CopyPathList(&pla,&plc,data->GlobalPath))
  136.         {
  137.         if (SystemTags(argstr ? argstr : entry->lau_cmd,
  138.             SYS_Output,     ofh,
  139.             SYS_Input,      ifh,
  140.             SYS_Asynch,     TRUE, 
  141.             SYS_UserShell,  TRUE,
  142.             NP_StackSize,   entry->lau_stack < 4096L ? 4096L : entry->lau_stack,
  143.             NP_Priority,    0,
  144.             NP_Path,        MKBADDR(pla),
  145.             NP_ConsoleTask, newct,
  146.             TAG_DONE)!=-1) rc=FALSE;
  147.         CurrentDir(oldcd);
  148.         if(rc)
  149.         {
  150.             Close(ifh);
  151.             FreePathList(pla);
  152.         }
  153.         }
  154.     }
  155.     if(rc)
  156.     {
  157.         Close(ofh);
  158.         DisplayBeep(0);
  159.     }
  160.     }
  161.     if(def)     pFreeVec(def);
  162.     if(argstr)  pFreeVec(argstr);
  163.     UnLock(newcd);
  164. }
  165.  
  166. RunWB(struct lau_entry *entry, struct tm_data *data, struct WBArg *wbarg, ULONG numarg)
  167. {
  168.     if(WBStartTags(WBStart_Name,                            entry->lau_cmd,
  169.            WBStart_DirectoryName,                   entry->lau_pth,
  170.            WBStart_Stack,                           entry->lau_stack < 4096L ? 4096L : entry->lau_stack,
  171.            wbarg ? WBStart_ArgumentList : TAG_END,  wbarg,
  172.            WBStart_ArgumentCount,                   numarg,
  173.            TAG_END))
  174.     {
  175.     DisplayBeep(0);
  176.     }
  177. }
  178.  
  179. int RunFile(struct lau_entry *entry, struct tm_data *data, struct WBArg *wbarg, ULONG numarg)
  180. {
  181.     if(entry->lau_type==0) RunWB(entry,data,wbarg,numarg);
  182.     else                   RunCLI(entry,data,wbarg,numarg);
  183. }
  184.