home *** CD-ROM | disk | FTP | other *** search
/ back2roots/padua / padua.7z / padua / amix / AmigaDOS-Emu.zoo / exec.c < prev    next >
C/C++ Source or Header  |  1992-01-14  |  4KB  |  200 lines
  1. #include <stdio.h>
  2.  
  3. #pragma pack(2)
  4. #include <exec/types.h>
  5. #include <exec/nodes.h>
  6. #include <exec/lists.h>
  7. #include <exec/ports.h>
  8. #include <exec/memory.h>
  9. #include <exec/tasks.h>
  10. #include <exec/libraries.h>
  11. #include <exec/execbase.h>
  12. #pragma pack()
  13.  
  14. #include "arun.h"
  15.  
  16.  
  17. void unsupp(char *X)
  18. {
  19.     panic("unsupported function at offset -0x%x in %s",
  20.       (&X)[-2] - (&X)[-1] + 6,
  21.       ((struct Library *)(&X)[-2])->lib_Node.ln_Name);
  22. }
  23.  
  24.  
  25. #define NFUNCS 400
  26. struct execlib {
  27.     struct func vectors[NFUNCS];
  28.     struct ExecBase lib;
  29. } execlib;
  30. struct ExecBase *const ExecBase = &execlib.lib;
  31.  
  32.  
  33.  
  34. extern void SSysBase_OpenLibrary(void);
  35. extern void SSysBase_OldOpenLibrary(void);
  36. extern void SSysBase_CloseLibrary(void);
  37. extern void SSysBase_AllocMem(void);
  38. extern void SSysBase_FreeMem(void);
  39. extern void SSysBase_FindTask(void);
  40. extern void SSysBase_SetSignal(void);
  41. extern void SSysBase_WaitPort(void);
  42. extern void SSysBase_Forbid(void);
  43. extern void SSysBase_Permit(void);
  44. static struct libinit { void (*func)(); int offset; } libinit[] =
  45. {
  46.     { SSysBase_OpenLibrary, -0x228, },
  47.     { SSysBase_OldOpenLibrary, -0x198, },
  48.     { SSysBase_CloseLibrary, -0x19e, },
  49.     { SSysBase_AllocMem, -0xc6, },
  50.     { SSysBase_FreeMem, -0xd2, },
  51.     { SSysBase_FindTask, -0x126, },
  52.     { SSysBase_SetSignal, -0x132, },
  53.     { SSysBase_WaitPort, -0x180, },
  54.     { SSysBase_Forbid, -0x84, },
  55.     { SSysBase_Permit, -0x8a, },
  56.     { 0, 0, },
  57. };
  58.  
  59.  
  60. void *exec_init(void)
  61. {
  62.     struct libinit *p2;
  63.     struct func *p;
  64.     int i;
  65.  
  66.     ExecBase->LibNode.lib_Node.ln_Name = "exec.library";
  67.  
  68.     /* First, fill all vectors with "unsupp" calls */
  69.     p = (struct func *)ExecBase;
  70.     for ( i=0 ; i<NFUNCS ; ++i )
  71.     {
  72.     --p;
  73.     p->opcode = 0x4eb9;    /* jsr N.l */
  74.     p->addr = unsupp;
  75.     }
  76.  
  77.     /* Now, fill in the supported vectors with the real jumps */
  78.     for ( p2=libinit ; p2->func ; ++p2 )
  79.     {
  80.     p = (struct func *)((char *)ExecBase + p2->offset);
  81.     p->opcode = 0x4ef9;    /* jmp N.l */
  82.     p->addr = p2->func;
  83.     }
  84.  
  85.     verbose("ExecBase = 0x%x", ExecBase);
  86.     return ExecBase;
  87. }
  88.  
  89.  
  90. static struct Library *ManxEnviron(void)
  91. {
  92.     extern char **environ;
  93.     char **p, *x;
  94.     int n;
  95. #pragma pack(2)
  96.     static struct { struct Library lib; char *env; } *ep;
  97. #pragma pack()
  98.  
  99.     if (ep)
  100.     return (struct Library *)ep;
  101.  
  102.     verbose("Building Manx environment");
  103.     ep = Malloc(sizeof *ep);
  104.  
  105.     n = 1;
  106.     for ( p=environ ; *p ; ++p )
  107.     n += strlen(*p) + 1;
  108.  
  109.     x = ep->env = Malloc(n);
  110.     for ( p=environ ; *p ; ++p )
  111.     {
  112.     strcpy(x, *p);
  113.     x += strlen(x) + 1;
  114.     }
  115.     *x++ = 0;
  116.  
  117.     return (struct Library *)ep;
  118. }
  119.  
  120.  
  121. struct Library *SysBase_OpenLibrary(char *libname, unsigned version)
  122. {
  123.     verbose("OpenLibrary(%s, %d)", libname, version);
  124.  
  125.     if (!strcmp(libname, "dos.library"))
  126.     return (struct Library *)DOSBase;
  127.  
  128.     if (!strcmp(libname, "environment"))
  129.     return ManxEnviron();
  130.  
  131.     return 0;
  132. }
  133. struct Library *SysBase_OldOpenLibrary(char *libname, unsigned version)
  134. {
  135.     return SysBase_OpenLibrary(libname, 0);
  136. }
  137. void SysBase_CloseLibrary(struct Library *lib)
  138. {
  139.     verbose("CloseLibrary(0x%x)");
  140. }
  141.  
  142. void *SysBase_AllocMem(ULONG nbytes, ULONG flags)
  143. {
  144.     extern void *malloc(unsigned nbytes);
  145.     void *p;
  146.  
  147.     if (flags&MEMF_CHIP)
  148.     {
  149.     warning("AllocMem(0x%x, MEMF_CHIP)", nbytes);
  150.     return 0;
  151.     }
  152.     verbose("AllocMem(0x%x, 0x%x)", nbytes, flags);
  153.     p = malloc(nbytes);
  154.     if (p && (flags&MEMF_CLEAR))
  155.     memset(p, 0, nbytes);
  156.     return p;
  157. }
  158. void SysBase_FreeMem(void *p, unsigned nbytes)
  159. {
  160.     extern void free(void *p);
  161.     verbose("FreeMem(0x%x, 0x%x)", p, nbytes);
  162.     free(p);
  163. }
  164.  
  165. struct Task *SysBase_FindTask(UBYTE *name)
  166. {
  167.     verbose("FindTask(%s)", name?(char *)name:"0");
  168.     if (!name || !strcmp(name, ExecBase->ThisTask->tc_Node.ln_Name))
  169.     return ExecBase->ThisTask;
  170.     return 0;
  171. }
  172.  
  173. ULONG SysBase_SetSignal(ULONG new, ULONG mask)
  174. {
  175.     ULONG old = ExecBase->ThisTask->tc_SigRecvd;
  176.     verbose("SetSignal(%08x, %08x)", new, mask);
  177.     if (mask)
  178.     ExecBase->ThisTask->tc_SigRecvd =
  179.         (ExecBase->ThisTask->tc_SigRecvd & ~mask) |
  180.         (new & mask);
  181.     return old;
  182. }
  183.  
  184. struct Message *SysBase_WaitPort(struct MsgPort *port)
  185. {
  186.     struct Message *msg;
  187.     verbose("WaitPort(0x%x)", port);
  188.     if (!(msg=(struct Message *)port->mp_MsgList.lh_Head))
  189.     panic("waiting forever");
  190.     return msg;
  191. }
  192.  
  193. void SysBase_Forbid(void)
  194. {
  195. }
  196.  
  197. void SysBase_Permit(void)
  198. {
  199. }
  200.