home *** CD-ROM | disk | FTP | other *** search
/ Club Amiga de Montreal - CAM / CAM_CD_1.iso / files / 552.lha / KeyMacro_v1.2 / Null-Handler.c < prev    next >
C/C++ Source or Header  |  1991-09-08  |  4KB  |  189 lines
  1. /* $Revision Header * Header built automatically - do not edit! *************
  2.  *
  3.  *    (C) Copyright 1990 by MXM
  4.  *
  5.  *    Name .....: Null-Handler.c
  6.  *    Created ..: Saturday 31-Mar-90 13:47
  7.  *    Revision .: 0
  8.  *
  9.  *    Date            Author          Comment
  10.  *    =========       ========        ====================
  11.  *    04-Apr-91       Olsen           Ported to SAS/C 5.10a
  12.  *    15-Apr-90       Olsen           Ported to Aztec 'C' 5.0
  13.  *    07-Jan-90       Olsen           Created this file!
  14.  *
  15.  *    Skeleton    handler    code   by   Phillip   Lindsay   (C)   1986
  16.  *    Commodore-Amiga,  Inc.  You may freely distribute this source and
  17.  *    use  it for Amiga Development, as long as the Copyright notice is
  18.  *    left intact.
  19.  *
  20.  ****************************************************************************
  21.  *
  22.  *    This  is  an  example how a 'real' NIL:  handler could look like.
  23.  *    It  is very loosely based on the 'my-handler' source code written
  24.  *    by Phillip Lindsay.
  25.  *
  26.  * $Revision Header ********************************************************/
  27.  
  28.     /* Main includes. */
  29.  
  30. #include <libraries/filehandler.h>
  31. #include <libraries/dosextens.h>
  32. #include <exec/execbase.h>
  33.  
  34. #include <pragmas/exec.h>
  35.  
  36.     /* Prototypes for this module. */
  37.  
  38. LONG __saveds            HandlerEntry(VOID);
  39. VOID __regargs            ReturnPacket(struct DosPacket *Packet,ULONG Res1,ULONG Res2,struct Process *HandlerProc);
  40. struct DosPacket * __regargs    WaitPacket(struct Process *HandlerProc);
  41.  
  42.     /* Global pointer to ExecBase. */
  43.  
  44. struct ExecBase        *SysBase;
  45.  
  46.     /* HandlerEntry():
  47.      *
  48.      *    The entry point for this handler.
  49.      */
  50.  
  51. LONG __saveds
  52. HandlerEntry()
  53. {
  54.     struct Process *HandlerProc;
  55.  
  56.         /* Set the ExecBase pointer. */
  57.  
  58.     SysBase = *(struct ExecBase **)4;
  59.  
  60.         /* Get a pointer to the process structure of the
  61.          * handler.
  62.          */
  63.  
  64.     HandlerProc = (struct Process *)SysBase -> ThisTask;
  65.  
  66.         /* If not called from CLI (you shouldn't do that)
  67.          * we'll start up as a DOS-handler.
  68.          */
  69.  
  70.     if(!HandlerProc -> pr_CLI)
  71.     {
  72.         struct DosPacket    *NullPacket;
  73.         struct DeviceNode    *NullNode;
  74.  
  75.             /* Wait for startup packet (we aren't a
  76.              * BCPL module).
  77.              */
  78.  
  79.         NullPacket = WaitPacket(HandlerProc);
  80.  
  81.             /* Get pointer to handler device node. */
  82.  
  83.         NullNode = (struct DeviceNode *)BADDR(NullPacket -> dp_Arg3);
  84.  
  85.             /* Install handler task ID -> we're running. */
  86.  
  87.         NullNode -> dn_Task = &HandlerProc -> pr_MsgPort;
  88.  
  89.             /* Return the startup packet to DOS. */
  90.  
  91.         ReturnPacket(NullPacket,DOSTRUE,NullPacket -> dp_Res2,HandlerProc);
  92.  
  93.             /* Run forever - or until somebody lets us die. */
  94.  
  95.         for(;;)
  96.         {
  97.                 /* Wait for a packet. */
  98.  
  99.             NullPacket = WaitPacket(HandlerProc);
  100.  
  101.                 /* Check the type. */
  102.  
  103.             switch(NullPacket -> dp_Type)
  104.             {
  105.                 case ACTION_FINDINPUT:
  106.                 case ACTION_FINDOUTPUT:
  107.                 case ACTION_FINDUPDATE:    
  108.                 case ACTION_END:    ReturnPacket(NullPacket,DOSTRUE,0,HandlerProc);
  109.                             break;
  110.  
  111.                 case ACTION_WRITE:    ReturnPacket(NullPacket,NullPacket -> dp_Arg3,0,HandlerProc);
  112.                             break;
  113.  
  114.                 case ACTION_READ:    ReturnPacket(NullPacket,0,0,HandlerProc);
  115.                             break;
  116.  
  117.                 case ACTION_DIE:    ReturnPacket(NullPacket,DOSTRUE,0,HandlerProc);
  118.                             goto FallOff;
  119.  
  120.                 default:        ReturnPacket(NullPacket,DOSFALSE,ERROR_ACTION_NOT_KNOWN,HandlerProc);
  121.                             break;
  122.             }
  123.         }
  124.  
  125.             /* Okay, we're done, zero the task ID field
  126.              * and fall through.
  127.              */
  128.     
  129. FallOff:    NullNode -> dn_Task = NULL;
  130.     }
  131. }
  132.  
  133.     /* ReturnPacket():
  134.      *
  135.      *    Returns a packet to DOS.
  136.      */
  137.  
  138. VOID __regargs
  139. ReturnPacket(struct DosPacket *Packet,ULONG Res1,ULONG Res2,struct Process *HandlerProc)
  140. {
  141.     struct MsgPort *ReplyPort;
  142.  
  143.         /* Remember origin port. */
  144.  
  145.     ReplyPort = Packet -> dp_Port;
  146.  
  147.         /* Fill in the result fields. */
  148.  
  149.     Packet -> dp_Res1 = Res1;
  150.     Packet -> dp_Res2 = Res2;
  151.  
  152.         /* Install our task ID. */
  153.  
  154.     Packet -> dp_Port = &HandlerProc -> pr_MsgPort;
  155.  
  156.         /* Initialize the packet node head. */
  157.  
  158.     Packet -> dp_Link -> mn_Node . ln_Name    = (char *)Packet;
  159.     Packet -> dp_Link -> mn_Node . ln_Succ    = NULL;
  160.     Packet -> dp_Link -> mn_Node . ln_Pred    = NULL;
  161.  
  162.         /* Return the packet to the sender. */
  163.  
  164.     PutMsg(ReplyPort,Packet -> dp_Link);
  165. }
  166.  
  167.     /* WaitPacket():
  168.      *
  169.      *    Wait for a DOS packet.
  170.      */
  171.  
  172. struct DosPacket * __regargs
  173. WaitPacket(struct Process *HandlerProc)
  174. {
  175.     struct Message *DOSMsg;
  176.  
  177.         /* Wait at the port... */
  178.  
  179.     WaitPort(&HandlerProc -> pr_MsgPort);
  180.  
  181.         /* Get the packet. */
  182.  
  183.     DOSMsg = (struct Message *)GetMsg(&HandlerProc -> pr_MsgPort);
  184.  
  185.         /* Return a pointer to its head. */
  186.  
  187.     return((struct DosPacket *)DOSMsg -> mn_Node . ln_Name);
  188. }
  189.