context.h

   1 #ifndef _context__h__included__
   2 #define _context__h__included__
   3
   4 struct vat;
   5 struct message;
   6 struct object;
   7 struct stack;
   8 #include <stdlib.h>
   9 #include "lock.h"
  10
  11 /* Context. */
  12 struct context;
  13
  14 /******************************************************************************
  15  *
  16  * DESCRIPTION:
  17  *      Pop object from stack. Popping empty stack gives NULL.
  18  *
  19  * PARAMETERS:
  20  *      ctx                     The context.
  21  *
  22  * RETURN VALUE:
  23  *      The object popped.
  24  *
  25  *****************************************************************************/
  26 struct object* context_pop(struct context* ctx);
  27
  28 /******************************************************************************
  29  *
  30  * DESCRIPTION:
  31  *      Push object to stack.
  32  *
  33  * PARAMETERS:
  34  *      ctx                     The context.
  35  *      obj                     The object to push.
  36  *
  37  *****************************************************************************/
  38 void context_push(struct context* ctx, struct object* obj);
  39
  40 /******************************************************************************
  41  *
  42  * DESCRIPTION:
  43  *      Notify context that execution is starting.
  44  *
  45  * PARAMETERS:
  46  *      ctx                     The context.
  47  *
  48  * RETURN VALUE:
  49  *      1 if suitable message was found, 0 if there is no suitable message.
  50  *
  51  *****************************************************************************/
  52 unsigned context_prepare(struct context* ctx);
  53
  54 /******************************************************************************
  55  *
  56  * DESCRIPTION:
  57  *      Notify context that execution is finished.
  58  *
  59  * PARAMETERS:
  60  *      ctx                     The context.
  61  *
  62  *****************************************************************************/
  63 void context_unprepare(struct context* ctx);
  64
  65 /******************************************************************************
  66  *
  67  * DESCRIPTION:
  68  *      Calculate number of stack slots.
  69  *
  70  * PARAMETERS:
  71  *      ctx                     The context.
  72  *
  73  *****************************************************************************/
  74 size_t context_stacksize(struct context* ctx);
  75
  76 /******************************************************************************
  77  *
  78  * DESCRIPTION:
  79  *      Single-step context.
  80  *
  81  * PARAMETERS:
  82  *      ctx                     The context.
  83  *
  84  *****************************************************************************/
  85 void context_singlestep(struct context* ctx);
  86
  87 /******************************************************************************
  88  *
  89  * DESCRIPTION:
  90  *      Create context.
  91  *
  92  * PARAMETERS:
  93  *      vat                     The vat to use.
  94  *
  95  * RETURN VALUE:
  96  *      The context. Pass to free when done.
  97  *
  98  *****************************************************************************/
  99 struct context* context_create(struct vat* vat);
 100
 101 /******************************************************************************
 102  *
 103  * DESCRIPTION:
 104  *      Grab context lock.
 105  *
 106  * PARAMETERS:
 107  *      ctx                     Context to lock.
 108  *
 109  *****************************************************************************/
 110 void context_lock(struct context* ctx);
 111
 112 /******************************************************************************
 113  *
 114  * DESCRIPTION:
 115  *      Ungrab context lock.
 116  *
 117  * PARAMETERS:
 118  *      ctx                     Context to unlock.
 119  *
 120  *****************************************************************************/
 121 void context_unlock(struct context* ctx);
 122
 123 /******************************************************************************
 124  *
 125  * DESCRIPTION:
 126  *      Queue message into message queue.
 127  *
 128  * PARAMETERS:
 129  *      context                 The context to use.
 130  *      message                 The message to queue.
 131  *
 132  *****************************************************************************/
 133 void context_queue_message(struct context* context, struct message* message);
 134
 135 /******************************************************************************
 136  *
 137  * DESCRIPTION:
 138  *      Execute message handler.
 139  *
 140  * PARAMETERS:
 141  *      context                 The context to use.
 142  *
 143  * RETURN VALUE:
 144  *      1 if message got handled, 0 if not.
 145  *
 146  *****************************************************************************/
 147 unsigned context_execute_msghandler(struct context* ctx);
 148
 149
 150 #endif