home *** CD-ROM | disk | FTP | other *** search
/ BCI NET 2 / BCI NET 2.iso / archives / programming / misc / amigem.lha / amigem / exec / tasks.c < prev   
Encoding:
C/C++ Source or Header  |  1995-01-30  |  5.4 KB  |  229 lines
  1. #include <exec/tasks.h>
  2. #include <exec/memory.h>
  3. #include <stdio.h>
  4. #include <amigem/utils.h>
  5. #include <clib/_exec.h>
  6. #include "exec.h"
  7.  
  8. #include <amigem/fd_lib.h>
  9. #define LIBBASE struct ExecBase *SysBase
  10.  
  11. #define FallAsleep     Private_1
  12. #define SwitchContext    Private_2
  13. #define AddContext    Private_3
  14. #define DISPATCH()    Cause(SysBase->SoftDispatch)
  15.  
  16. #define DISPATCH_PENDING 1
  17.  
  18. FD0F(22,p,void,Forbid)
  19. {
  20.   SysBase->TDNestCnt++;
  21. }
  22.  
  23. FD0F(23,p,void,Permit)
  24. {
  25.   if(!SysBase->TDNestCnt--&&SysBase->SysFlags&DISPATCH_PENDING)
  26.     DISPATCH();
  27. }
  28.  
  29. FC1F(0,d,void,UserTask,A0,struct ExecBase *SysBase,A6)
  30. ;
  31.  
  32. FC2F(0,b,void,NewTask,A5,APTR is_data,A1,struct ExecBase *SysBase,A6)
  33. {
  34.   APTR *buf=(APTR *)is_data;
  35.   Enable(); /* Called in disabled state */
  36.   UserTask(buf[0],SysBase);
  37.   if(buf[1]!=NULL)
  38.     UserTask(buf[1],SysBase);
  39.   else
  40.     RemTask(0);
  41. }
  42.  
  43. FD3(47,APTR,AddTask,struct Task *task,A1,APTR initialPC,A2,APTR finalPC,A3)
  44. {
  45.   APTR *buf;
  46.   if(!task->tc_Node.ln_Type)
  47.     task->tc_Node.ln_Type=NT_TASK;
  48.   if(!task->tc_Node.ln_Name)
  49.     task->tc_Node.ln_Name="unknown task";
  50.   task->tc_State=TS_READY;
  51.   if(!task->tc_SigAlloc)
  52.     task->tc_SigAlloc=0xffff;
  53.   /* exceptions & traps */
  54.   if(!task->tc_SPReg)
  55.     task->tc_SPReg=STACKPOINTER(task->tc_SPLower,task->tc_SPUpper);
  56.   /* switch & launch */
  57.   buf=(APTR *)ALLOCONSTACK(&task->tc_SPReg,2*sizeof(APTR));
  58.   buf[0]=initialPC;
  59.   buf[1]=finalPC;
  60.   task->tc_SPReg=AddContext(task->tc_SPReg,&__NewTask,buf);
  61.   task->tc_State=TS_READY;
  62.   Disable();
  63.     Enqueue(&SysBase->TaskReady,&task->tc_Node);
  64.     DISPATCH();
  65.   Enable();
  66.   return task;
  67. }
  68.  
  69. FD1(48,void,RemTask,struct Task *task,A1)
  70. {
  71.   Forbid(); /* The following may free the task structure */
  72.   {
  73.     struct MemList *mb; /* Free all memory */
  74.     struct Task *t=(task==NULL?SysBase->ThisTask:task);
  75.     while((mb=(struct MemList *)RemHead(&t->tc_MemEntry))!=NULL)
  76.     {
  77.       FreeEntry(mb);
  78.       FreeMem(mb,sizeof(struct MemList)-sizeof(struct MemEntry)+
  79.                  mb->ml_NumEntries*sizeof(struct MemEntry));
  80.     }
  81.     Disable();
  82.       if(!task) /* cannot remove myself - let the dispatcher do it */
  83.       {
  84.         t->tc_State=TS_REMOVED;
  85.         DISPATCH();
  86.         SysBase->TDNestCnt=-1;
  87.         SysBase->IDNestCnt=0;
  88.         Enable();
  89.         for(;;) /* Dispatcher could not remove this task */
  90.           FallAsleep();
  91.       }
  92.       else
  93.         Remove(&task->tc_Node);
  94.     Enable();
  95.   }
  96.   Permit();
  97. }
  98.  
  99. FD2(50,BYTE,SetTaskPri,struct Task *task,A1,long pri,D0)
  100. {
  101.   BYTE old;
  102.   Disable();
  103.     old=task->tc_Node.ln_Pri;
  104.     task->tc_Node.ln_Pri=pri;
  105.     if(task->tc_State!=TS_WAIT)
  106.     {
  107.       if(task!=SysBase->ThisTask)
  108.       { Remove(&task->tc_Node);
  109.         Enqueue(&SysBase->TaskReady,&task->tc_Node); }
  110.       DISPATCH();
  111.     }
  112.   Enable();
  113.   return old;
  114. }
  115.  
  116. FD1(49,struct Task *,FindTask,STRPTR name,A1)
  117. { 
  118.   struct Task *ret;
  119.   if(name==NULL)
  120.     ret=SysBase->ThisTask;
  121.   else
  122.   {
  123.     Disable();
  124.       if((ret=(struct Task *)FindName(&SysBase->TaskReady,name))==NULL)
  125.         if((ret=(struct Task *)FindName(&SysBase->TaskWait,name))==NULL)
  126.         {
  127.           char *s1=SysBase->ThisTask->tc_Node.ln_Name;
  128.           char *s2=name;
  129.           while(*s1++==*s2)
  130.             if(!*s2++)
  131.             { 
  132.               ret=SysBase->ThisTask;
  133.               break;
  134.             }
  135.         }
  136.     Enable();
  137.   }
  138.   return ret;
  139. }
  140.  
  141. FC3(0,ULONG,UserException,A0,ULONG signals,D0,APTR exceptData,A1,struct ExecBase *SysBase,A6)
  142. ;
  143.  
  144. FC2F(0,b,void,ExceptionMode,A5,ULONG sigs,A1,struct ExecBase *SysBase,A6)
  145. {
  146.   struct Task *me=SysBase->ThisTask;
  147.   do
  148.   {
  149.     APTR code,data;
  150.     code=me->tc_ExceptCode;
  151.     data=me->tc_ExceptData;
  152.     Enable(); /* Function is called Disabled */
  153.       sigs=UserException(code,sigs,data,SysBase);
  154.     Disable();
  155.     me->tc_SigExcept|=sigs;
  156.     sigs=me->tc_SigExcept&me->tc_SigRecvd;
  157.     me->tc_SigRecvd &=~sigs;
  158.     me->tc_SigExcept&=~sigs;
  159.   }while(sigs);
  160. }
  161.  
  162. FC2F(0,bi,LONG,Dispatcher,A5,APTR is_data,A1,struct ExecBase *SysBase,A6)
  163. {
  164.   struct Task *t1,*t2;
  165.  
  166.   Disable(); /* Arbitrate for SysBase */
  167.  
  168.   SysBase->SysFlags&=~DISPATCH_PENDING;
  169.  
  170.   t1=SysBase->ThisTask;
  171.   if(t1->tc_State==TS_EXCEPT) /* A task that wants to run in exception mode */
  172.   {
  173.     ULONG sigs;
  174.     sigs=t1->tc_SigExcept&t1->tc_SigRecvd;
  175.     t1->tc_SigRecvd &=~sigs;
  176.     t1->tc_SigExcept&=~sigs;
  177.     SwitchContext(AddContext(SwitchContext(NULL),&__ExceptionMode,(APTR)sigs));
  178.     t1->tc_State=TS_RUN;
  179.     goto end;
  180.   }
  181.  
  182.   t2=(struct Task *)SysBase->TaskReady.lh_Head;
  183.   if(!t2->tc_Node.ln_Succ)
  184.     goto end; /* No ready task - no dispatching */
  185.  
  186.   if(SysBase->TDNestCnt!=-1) /* sceduling disabled */
  187.   { SysBase->SysFlags|=DISPATCH_PENDING;
  188.     goto end; }
  189.  
  190.   switch(t1->tc_State)
  191.   {
  192.     default:  /* illegal task state - treat it as TS_RUN */
  193.     case TS_RUN: /* normal dispatching */
  194.       if(t2->tc_Node.ln_Pri<t1->tc_Node.ln_Pri) /* priority too low */
  195.         goto end;
  196.       Enqueue(&SysBase->TaskReady,&t1->tc_Node);
  197.       t1->tc_State=TS_READY;
  198.       break;
  199.     case TS_WAIT: /* A task that wants to go into the waiting queue */
  200.       Enqueue(&SysBase->TaskWait,&t1->tc_Node);
  201.       break;
  202.     case TS_REMOVED: /* A task that wants to be removed */
  203.       break; /* simply don't feed the waiting queue */
  204.   }
  205.  
  206.   t1->tc_SPReg=SwitchContext(t2->tc_SPReg);
  207.   Remove(&t2->tc_Node);
  208.   SysBase->ThisTask=t2;
  209.   t2->tc_State=TS_RUN;
  210.   SysBase->DispCount++;
  211.  
  212. end:
  213.   Enable();
  214.   return 0;
  215. }
  216.  
  217. /* No documentation available */
  218. FD1(123,void,ChildFree,APTR tid,D0)
  219. {}
  220.  
  221. FD1(124,void,ChildOrphan,APTR tid,D0)
  222. {}
  223.  
  224. FD1(125,void,ChildStatus,APTR tid,D0)
  225. {}
  226.  
  227. FD1(126,void,ChildWait,APTR tid,D0)
  228. {}
  229.