home *** CD-ROM | disk | FTP | other *** search
/ Enigma Amiga Life 113 / EnigmaAmiga113CD.iso / software / sviluppo / fm2000 / execute.c < prev    next >
Encoding:
C/C++ Source or Header  |  2000-02-04  |  11.7 KB  |  536 lines
  1. /*
  2.      Filemaster - Multitasking directory utility.
  3.      Copyright (C) 2000  Toni Wilen
  4.      
  5.      This program is free software; you can redistribute it and/or
  6.      modify it under the terms of the GNU General Public License
  7.      as published by the Free Software Foundation; either version 2
  8.      of the License, or (at your option) any later version.
  9.      
  10.      This program is distributed in the hope that it will be useful,
  11.      but WITHOUT ANY WARRANTY; without even the implied warranty of
  12.      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13.      GNU General Public License for more details.
  14.      
  15.      You should have received a copy of the GNU General Public License
  16.      along with this program; if not, write to the Free Software
  17.      Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  18. */
  19.  
  20. #include <proto/all.h>
  21. #include <exec/types.h>
  22. #include <dos/dostags.h>
  23. #include <dos/dosextens.h>
  24. #include <strings.h>
  25. #include <stdio.h>
  26. #include "fmnode.h"
  27. #include "fmdos.h"
  28. #include "child.h"
  29. #include "fmlocale.h"
  30. #include "fmgui.h"
  31.  
  32. struct ExecuteConfig {
  33.     UBYTE shellwindow[80];
  34.     BYTE timeout;
  35. };
  36.  
  37. void executefile(struct FMHandle *h,struct CMenuConfig *cmc);
  38. void executeexe(struct FMList*,struct FMList*,UBYTE*,struct CMenuConfig*,struct ExecuteFlags*);
  39. void executeown(struct FMList*,struct FMList*,struct FMNode*,struct CMenuConfig*);
  40. WORD deloldexe(WORD);
  41. WORD txtwrite(BPTR,UBYTE*,WORD);
  42. UBYTE *scanchar(UBYTE*,UBYTE);
  43. void readdir(struct FMList*);
  44.  
  45. extern struct FMMain fmmain;
  46. extern struct FMConfig *fmconfig;
  47.  
  48. void __saveds execute(void)
  49. {
  50. struct ProcMsg *pm;
  51. struct FMList *list;
  52. struct FMNode *node;
  53. struct FMHandle *h;
  54. struct FMHandle hh;
  55. UBYTE byt=0;
  56.  
  57. pm=sinitproc();
  58. list=fmmain.sourcedir;
  59. if (!(setalloc(list,1))) {
  60.     initproc(0,0); 
  61.     goto endi;
  62. }
  63. initproc(list,pm->cmc->label);
  64. priority(pm->cmc);
  65. if((node=findselnode(list))) {
  66.     if (h=openfile(list,NDFILE(node),OFNORMAL)) {
  67.         executefile(h,pm->cmc);
  68.         closefile(h);
  69.     }
  70.     node->flags&=~NSELECTED;
  71.     outputlistline(list,node);
  72. } else {
  73.     hh.filename=&byt;
  74.     hh.owner=list;
  75.     executefile(&hh,pm->cmc);
  76. }
  77. endproc(list);
  78. endi:
  79. deinitproc(pm);
  80. }
  81.  
  82. void executefile(struct FMHandle *h,struct CMenuConfig *cmc)
  83. {
  84. struct GUIBase *gb;
  85. WORD c;
  86. UBYTE params[128];
  87. LONG timeout;
  88. WORD shellw;
  89. struct ExecuteConfig *ec;
  90. struct ExecuteFlags ef={0};
  91.  
  92. changename(h->owner,cmc->label);
  93. priority(cmc);
  94. ec=getconfig(cmc);
  95. if(h->filename[0]) sformatmsg(h->owner->fmmessage1,MSG_FILECLICK_EXECUTABLE,h->filename);
  96. fmmessage(h->owner);
  97. strcpy(params,h->filename);
  98. gb=getguibase(cmc->label);
  99. setconnectgroup(gb,1,0,0);
  100. reqinfomsg(gb,MSG_EXE_COMMAND,200,guiUC|guiLEFT);
  101. reqstring(gb,200,params,sizeof(params));
  102. timeout=ec->timeout;
  103. setconnectgroup(gb,2,0,0);
  104. reqinfomsg(gb,MSG_EXE_TIMEOUT,201,guiUC|guiLEFT);
  105. reqinteger(gb,201,&timeout,-1,99);
  106. shellw=0;
  107. setconnectgroup(gb,3,0,0);
  108. reqinfomsg(gb,MSG_EXE_SHELLWINDOW,202,guiUC|guiLEFT);
  109. reqcycle2msg(gb,202,&shellw);
  110. buttonbarmsg(gb,MSG_OK,1,MSG_CANCEL,0,0);
  111. c=quickreq(gb);
  112. if (c) {
  113.     ef.shellwindow=shellw;
  114.     ef.stack=10000;
  115.     ef.timeout=timeout;
  116.     executeexe(h->owner,fmmain.destdir,params,cmc,&ef);
  117. }
  118. }
  119.  
  120. void executeexe(struct FMList *list,struct FMList *dlist,UBYTE *command,struct CMenuConfig *cmc,struct ExecuteFlags *ef2)
  121. {
  122. struct Process *proc,*proc2;
  123. APTR window=0;
  124. BPTR lock,tlock;
  125. WORD c,apu1;
  126. UBYTE exename[32];
  127. UBYTE para[PATH];
  128. struct CommandLineInterface *cli;
  129. ULONG  *fl;
  130. WORD len;
  131. UBYTE *shellwindow;
  132. UBYTE fmexe[32];
  133. WORD signal=-1;
  134. struct ExecuteFlags ef;
  135.  
  136. CopyMem(ef2,&ef,sizeof(struct ExecuteFlags));
  137. if(!deloldexe(0)) goto xerror;
  138.  
  139. proc=(struct Process*)FindTask(0);
  140. window=proc->pr_WindowPtr;
  141. proc->pr_WindowPtr=(APTR)-1;
  142.  
  143. shellwindow=((struct ExecuteConfig*)(getconfig(getconfignumber(EXECUTECONFIG))))->shellwindow;
  144.  
  145. if(!command[0]) ef.shellwindow=1;
  146. for(c=0;c<10;c++) {
  147.     sformat(exename,"t:fmexe.tmp%ld",c);
  148.     if(!(lock=Lock(exename,SHARED_LOCK))) break;
  149.     UnLock(lock);
  150. }
  151. if(c>=10) goto xerror;
  152.  
  153. lock=Open(exename,1006);
  154. if(!lock) goto xerror;
  155.  
  156. apu1=0;len=101;
  157.  
  158. cli=(struct CommandLineInterface*)(fmmain.myproc->pr_CLI<<2);
  159. fl=(ULONG*)(cli->cli_CommandDir<<2);
  160. if(!fl) {
  161.     proc2=(struct Process*)FindTask("Workbench");
  162.     if(proc2) {
  163.         cli=(struct CommandLineInterface*)(proc2->pr_CLI<<2);
  164.         fl=(ULONG*)(cli->cli_CommandDir<<2);
  165.     }
  166. }
  167. while(fl) {
  168.     if(NameFromLock((BPTR)fl[1],para,PATH)) {
  169.         if(len>100) {
  170.             if(apu1) txtwrite(lock," add",1);
  171.             txtwrite(lock,"Path >NIL:",0);
  172.             len=0;apu1=1;
  173.         }
  174.         txtwrite(lock," \"",0);
  175.         txtwrite(lock,para,0);
  176.         txtwrite(lock,"\"",0);
  177.         len+=strlen(para)+3;
  178.     }
  179.     fl=(ULONG*)(fl[0]<<2);
  180. }
  181. if(apu1) txtwrite(lock," add",1);
  182.  
  183. sformat(para,"NewCLI \"%s\" from %s",shellwindow,exename);
  184. if(command[0]) {
  185.     txtwrite(lock,"Failat 10000000",1);
  186.     txtwrite(lock,command,1);
  187.     if(ef.timeout>0) {
  188.         sformat(fmexe,"Wait %ld SEC",ef.timeout);
  189.         txtwrite(lock,fmexe,1);
  190.     }
  191.     txtwrite(lock,"t:fmexe ",0);
  192.     if(ef.timeout<0) txtwrite(lock,"K ",0);
  193.     if(ef.rescan) {
  194.         signal=AllocSignal(-1);
  195.         sformat(fmexe,"S:%ld:%ld ",FindTask(0),signal);
  196.         txtwrite(lock,fmexe,0);
  197.     }
  198.     if(ef.endfront) {
  199.         sformat(fmexe,"P:%ld ",ef.endfront==1?fmmain.naytto:0);
  200.         txtwrite(lock,fmexe,0);
  201.     }
  202.     txtwrite(lock," ",1);
  203.     if(ef.shellwindow) {
  204.         txtwrite(lock,"EndCLI >NIL:",1);
  205.     } else {
  206.         sformat(para,"Run >NIL: Execute \"%s\"",exename);
  207.     }
  208. } else {
  209.     tlock=Lock("S:Shell-StartUp",SHARED_LOCK);
  210.     if(tlock) {
  211.         txtwrite(lock,"Execute S:Shell-StartUp",1);
  212.         UnLock(tlock);
  213.     }
  214. }
  215. Close(lock);
  216. if(window) proc->pr_WindowPtr=window;
  217. window=0;
  218. lock=Open("NIL:",1005);
  219. if(!lock) goto xerror;
  220. if(ef.startfront==2) WBenchToFront();
  221. if(ef.startfront==1) ScreenToFront(fmmain.naytto);
  222. apu1=Execute(para,0,lock);
  223. Close(lock);
  224.  
  225. if(signal>=0) {
  226.     Wait(1L<<signal);
  227.     FreeSignal(signal);
  228.     if(ef.rescan&1) readdir(list);
  229.     if(ef.rescan&2) readdir(dlist);
  230. }
  231.  
  232. if(apu1) return;
  233. xerror:
  234. if(window) proc->pr_WindowPtr=window;
  235. requestmsg(cmc->label,0,MSG_OK,MSG_EXE_FAILED);
  236. }
  237.  
  238. WORD deloldexe(WORD ide)
  239. {
  240. UBYTE exename[32];
  241. WORD ret=0;
  242. WORD aa;
  243. BPTR lock;
  244. APTR win;
  245. struct Process *proc;
  246.  
  247. extern UBYTE fmexe[];
  248. extern UBYTE fmexee[];
  249.  
  250. proc=(struct Process*)FindTask(0);
  251. win=proc->pr_WindowPtr;
  252. proc->pr_WindowPtr=(APTR)-1;
  253. if(!(lock=Lock("t:",SHARED_LOCK))) goto endi;
  254. UnLock(lock);
  255. for(aa=0;aa<10;aa++) {
  256.     sformat(exename,"t:fmexe.tmp%ld",aa);
  257.     DeleteFile(exename);
  258. }
  259. if(lock=Lock("t:fmexe",SHARED_LOCK)) {
  260.     UnLock(lock);
  261.     return(1);
  262. }
  263. if(ide) {
  264.     DeleteFile("t:fmexe");
  265. } else {
  266.     lock=Open("t:fmexe",1006);
  267.     if(!lock) goto endi;
  268.     Write(lock,fmexe,fmexee-fmexe);
  269.     Close(lock);
  270. }
  271. ret=1;
  272. endi:
  273. proc->pr_WindowPtr=win;
  274. return(ret);
  275. }
  276.  
  277. WORD txtwrite(BPTR handle,UBYTE *ptr,WORD eof)
  278. {
  279. Write(handle,ptr,strlen(ptr));
  280. if(eof) Write(handle,"\n",1);
  281. return(1);
  282. }
  283.  
  284. void __saveds executeownnum(void)
  285. {
  286. struct ProcMsg *pm;
  287. struct FMList *list;
  288.  
  289. pm=sinitproc();
  290. list=fmmain.sourcedir;
  291. if (!(setalloc(list,1))) {
  292.     initproc(0,0);
  293.     goto endi;
  294. }
  295. initproc(list,pm->cmc->label);
  296. priority(pm->cmc);
  297. executeown(list,fmmain.destdir,0,pm->cmc);
  298. endproc(list);
  299. endi:
  300. deinitproc(pm);
  301. }
  302.  
  303. void executeown(struct FMList *slist,struct FMList *dlist,struct FMNode *cnode,struct CMenuConfig *cmc)
  304. {
  305. struct OwnCommand *oc;
  306. UBYTE command[1000];
  307. UBYTE varapath[PATH],vara[PATH];
  308. UBYTE *ptr1,*ptr2,*ptr3;
  309. WORD apu1,apu2,apu3;
  310. struct FMNode *node;
  311. WORD dalloc=0;
  312.  
  313. oc=getconfig(cmc);
  314. changename(slist,cmc->label);
  315. priority(cmc);
  316.  
  317. if(oc->ef.rescan&2) {
  318.     if(!(setalloc(dlist,1))) goto endi;
  319.     changename(dlist,cmc->label);
  320.     dalloc=1;
  321. }
  322.  
  323. ptr1=oc->command;
  324. if(*ptr1==0) goto endi;
  325. ptr2=command;
  326.  
  327. *ptr2=0;
  328. if(oc->ef.cd==2) {
  329.     if(!dlist->path[0]) {
  330.         strcpymsg(slist->fmmessage1,MSG_MAIN_NODESTINATION);
  331.         fmmessage(slist);
  332.         goto endi;
  333.     }
  334.     sformat(ptr2,"CD %lc%s%lc\n",'"',dlist->path,'"');
  335. }
  336. if(oc->ef.cd==1) {
  337.     if(!slist->path[0]) {
  338.         strcpymsg(slist->fmmessage1,MSG_MAIN_NOSOURCE);
  339.         fmmessage(slist);
  340.     }
  341.     sformat(ptr2,"CD %lc%s%lc\n",'"',slist->path,'"');
  342. }
  343. ptr2+=strlen(ptr2);
  344. sformat(ptr2,"Stack %ld\n",oc->ef.stack);
  345. ptr2+=strlen(ptr2);
  346.  
  347. while(*ptr1) {
  348.     if(*ptr1=='{') {
  349.         ptr1++;
  350.         *ptr2=0;
  351.         switch(*ptr1)
  352.         {
  353.         case 'd':
  354.         *ptr2++=34;
  355.         strcpy(ptr2,dlist->path);
  356.         ptr2+=strlen(ptr2);
  357.         *ptr2++=34;
  358.         break;
  359.         case 's':
  360.         *ptr2++=34;
  361.         strcpy(ptr2,slist->path);
  362.         ptr2+=strlen(ptr2);
  363.         *ptr2++=34;
  364.         break;
  365.         case 'f':
  366.         case 'F':
  367.         case 'o':
  368.         case 'O':
  369.         apu1=0;apu2=0;
  370.         if(*ptr1=='f'||*ptr1=='F') apu1=1;
  371.         if(*ptr1=='F'||*ptr1=='O') apu2=1;
  372.         if(cnode&&!apu2) {
  373.             node=cnode;
  374.             node->flags&=~NSELECTED;
  375.             *ptr2++=34;
  376.             if(apu1) {
  377.                 strcpy(varapath,slist->path);
  378.                 AddPart(varapath,NDFILE(node),PATH);
  379.                 strcpy(ptr2,varapath);
  380.             } else {
  381.                 strcpy(ptr2,NDFILE(node));
  382.             }
  383.             ptr2+=strlen(ptr2);
  384.             *ptr2++=34;
  385.         } else {    
  386.             apu3=0;
  387.             for(node=slist->head;node->succ;node=node->succ) {
  388.                 if(node->flags&NSELECTED) {
  389.                     node->flags&=~NSELECTED;
  390.                     if(apu3) *ptr2++=32;
  391.                     *ptr2++=34;
  392.                     if(apu1) {
  393.                         strcpy(varapath,slist->path);
  394.                         AddPart(varapath,NDFILE(node),PATH);
  395.                         strcpy(ptr2,varapath);
  396.                     } else {
  397.                         strcpy(ptr2,NDFILE(node));
  398.                     }
  399.                     ptr2+=strlen(ptr2);
  400.                     *ptr2++=34;
  401.                     apu3=1;
  402.                     if(!apu2) break;
  403.                 }
  404.             }
  405.         }
  406.         break;
  407.         case 'r':
  408.         ptr1=scanchar(ptr1,',');
  409.         if(!ptr1) goto serror;
  410.         ptr1++;
  411.         ptr3=scanchar(ptr1,'}');
  412.         if(!ptr3) goto serror;
  413.         memseti(vara,0,PATH);
  414.         strncpy(vara,ptr1,ptr3-ptr1);
  415.         if(!askstring(0,cmc->label,vara,varapath,80)) goto endi;
  416.         strcpy(ptr2,varapath);
  417.         ptr2+=strlen(ptr2);
  418.         break;
  419.         }
  420.         ptr1=scanchar(ptr1,'}');
  421.         if(!ptr1) goto serror;
  422.         ptr1++;
  423.     } else {
  424.         *ptr2++=*ptr1++;
  425.     }
  426. }
  427. *ptr2=0;
  428.  
  429. sformatmsg(slist->fmmessage1,MSG_EXE_EXECUTING,cmc->label);
  430. fmmessage(slist);
  431. executeexe(slist,dlist,command,cmc,&oc->ef);
  432. goto endi;
  433. serror:
  434. requestmsg(cmc->label,0,MSG_OK,MSG_EXE_SYNTAXERROR,cmc->label);
  435. endi:
  436. if(dalloc) setalloc(dlist,0);
  437. outputlist(slist);
  438. }
  439.  
  440. void *ownexecuteconfigdefault(struct CMenuConfig *cmc)
  441. {
  442. WORD ret;
  443. struct OwnCommand *oc;
  444.  
  445. ret=allocconfig(cmc,sizeof(struct OwnCommand));
  446. if(ret<0) return(cmc->moreconfig);
  447. if(!ret) return(0);
  448. oc=(struct OwnCommand*)cmc->moreconfig;
  449. cmc->cmenucount=100;
  450. oc->ef.stack=8000;
  451. oc->ef.timeout=2;
  452. return(cmc->moreconfig);
  453. }
  454.  
  455. void *executeconfigdefault(struct CMenuConfig *cmc)
  456. {
  457. struct ExecuteConfig *config;
  458. WORD ret;
  459.  
  460. ret=allocconfig(cmc,sizeof(struct ExecuteConfig));
  461. if(ret<0) return(cmc->moreconfig);
  462. if(!ret) return(0);
  463. config=cmc->moreconfig;
  464. strcpy(config->shellwindow,"CON:////FileMaster Shell/SCREEN FM");
  465. config->timeout=2;
  466. return(cmc->moreconfig);
  467. }
  468.  
  469. void initexes(WORD cnt1)
  470. {
  471. struct OwnCommand *oc;
  472. struct CMenuConfig *cmc;
  473.  
  474. executeconfigdefault(&fmconfig->cmenuconfig[EXECUTECONFIG]);
  475. cmc=&fmconfig->cmenuconfig[cnt1++];
  476. cmc->position=1;
  477. oc=ownexecuteconfigdefault(cmc);
  478. if(oc) {
  479.     strcpy(cmc->label,"LhA x");
  480.     strcpy(oc->namematch,"*.(lha|lzh)");
  481.     strcpy(oc->command,"lha x {f}");
  482.     strcpy(oc->matchbytes,"2,$2d6c68");
  483.     oc->ef.shellwindow=1;
  484.     oc->ef.cd=2;
  485.     oc->ef.rescan=2;
  486.     oc->ef.stack=8000;
  487. }
  488. cmc=&fmconfig->cmenuconfig[cnt1++];
  489. cmc->position=1;
  490. oc=ownexecuteconfigdefault(cmc);
  491. if(oc) {
  492.     strcpy(cmc->label,"LhA a");
  493.     strcpy(oc->command,"lha a {r,Archive name} {F}");
  494.     oc->ef.shellwindow=1;
  495.     oc->ef.cd=2;
  496.     oc->ef.rescan=2;
  497.     oc->ef.stack=8000;
  498. }
  499.  
  500. cmc=&fmconfig->cmenuconfig[cnt1++];
  501. cmc->position=1;
  502. oc=ownexecuteconfigdefault(cmc);
  503. if(oc) {
  504.     strcpy(cmc->label,"AGuide");
  505.     if(fmmain.kick>=39)
  506.         strcpy(oc->command,"sys:utilities/multiview {f}");
  507.         else
  508.         strcpy(oc->command,"sys:utilities/amigaguide {f}");
  509.     strcpy(oc->namematch,"#?.guide");
  510.     oc->ef.startfront=1;
  511.     oc->ef.endfront=1;
  512.     oc->ef.timeout=0;
  513.     oc->ef.stack=8000;
  514. }
  515. }
  516.  
  517. WORD executeconfig(struct GUIBase *gb,struct CMenuConfig *cmc)
  518. {
  519. WORD c;
  520. struct ExecuteConfig *ec;
  521. LONG timeout;
  522.  
  523. ec=executeconfigdefault(cmc);
  524. setguigroup(gb,1,0);
  525. reqinfomsg(gb,MSG_EXE_SHELLWINDOW,200,guiUC|guiLEFT);
  526. reqinfomsg(gb,MSG_EXE_TIMEOUT,201,guiUC|guiLEFT);
  527. setguigroup(gb,2,0);
  528. reqstring(gb,200,ec->shellwindow,sizeof(ec->shellwindow));
  529. timeout=ec->timeout;
  530. reqinteger(gb,201,&timeout,-1,99);
  531. commandanswer(gb);
  532. c=quickreq(gb);
  533. ec->timeout=timeout;
  534. return(c);
  535. }
  536.