chiark - git - mdw - ssr/blob - StraySrc/Libraries/Sapphire/csapph/h/flex

   1 /*
   2  * flex.h
   3  *
   4  * [Generated from flex, 25 September 1996]
   5  */
   6
   7 #if !defined(__CC_NORCROFT) || !defined(__arm)
   8   #error You must use the Norcroft ARM Compiler for Sapphire programs
   9 #endif
  10
  11 #pragma include_only_once
  12 #pragma force_top_level
  13
  14 #ifndef __flex_h
  15 #define __flex_h
  16
  17 #ifndef __sapphire_h
  18   #include "sapphire.h"
  19 #endif
  20
  21 /*----- Overview ----------------------------------------------------------*
  22  *
  23  * Functions provided:
  24  *
  25  *  flex_reduce
  26  *  flex_compact
  27  *  flex_free
  28  *  flex_alloc
  29  *  flex_size
  30  *  flex_extend
  31  *  flex_midExtend
  32  *  flex_init
  33  *  flex_stackPtr
  34  *  flex_save
  35  *  flex_load
  36  *  flex_dump
  37  *
  38  * Macros provided:
  39  *
  40  *   FSAVE
  41  *   FLOAD
  42  */
  43
  44 /* --- flex_reduce --- *
  45  *
  46  * On entry:    --
  47  *
  48  * On exit:     --
  49  *
  50  * Use:         Compacts the flex heap by one iteration.
  51  */
  52
  53 extern routine flex_reduce;
  54
  55 /* --- flex_compact --- *
  56  *
  57  * On entry:    --
  58  *
  59  * On exit:     --
  60  *
  61  * Use:         Completely compacts the flex heap.
  62  */
  63
  64 extern routine flex_compact;
  65
  66 /* --- flex_free --- *
  67  *
  68  * On entry:    R0 == pointer to the flex anchor
  69  *
  70  * On exit:     --
  71  *
  72  * Use:         Frees a flex block allocated by flex_alloc.
  73  */
  74
  75 extern routine flex_free;
  76
  77 /* --- flex_alloc --- *
  78  *
  79  * On entry:    R0 == pointer to a flex anchor
  80  *              R1 == desired size of flex block
  81  *
  82  * On exit:     CS if no memory could be allocated, CC otherwise
  83  *
  84  * Use:         Allocates a block in the shifting heap.
  85  */
  86
  87 extern routine flex_alloc;
  88
  89 /* --- flex_size --- *
  90  *
  91  * On entry:    R0 == pointer to flex anchor
  92  *
  93  * On exit:     R0 == size of allocated block
  94  *
  95  * Use:         Reads the size of a flex block.
  96  */
  97
  98 extern routine flex_size;
  99
 100 /* --- flex_extend --- *
 101  *
 102  * On entry:    R0 == pointer to flex anchor
 103  *              R1 == new size of block to set
 104  *
 105  * On exit:     CS if it failed due to lack of memory, CC otherwise
 106  *
 107  * Use:         Alters the size of a block to the given value.
 108  */
 109
 110 extern routine flex_extend;
 111
 112 /* --- flex_midExtend --- *
 113  *
 114  * On entry:    R0 == pointer to a flex anchor
 115  *              R1 == `at' -- position in block to extend from
 116  *              R2 == `by' -- how many bytes to extend (may be -ve)
 117  *
 118  * On exit:     CS if it failed due to lack of memory, CC otherwise
 119  *
 120  * Use:         Either creates a gap in a block (by>0) or deletes bytes
 121  *              from a block.  This is always done in such a way that the
 122  *              byte originally at offset `at' is now at offset `at'+`by'.
 123  */
 124
 125 extern routine flex_midExtend;
 126
 127 /* --- flex_init --- *
 128  *
 129  * On entry:    --
 130  *
 131  * On exit:     --
 132  *
 133  * Use:         Initialises the flex heap for use.
 134  */
 135
 136 extern routine flex_init;
 137
 138 /* --- flex_stackPtr --- *
 139  *
 140  * On entry:    R0 == 0 to read, or value to set
 141  *
 142  * On exit:     R0 == old value
 143  *
 144  * Use:         Either reads or writes the flex stack pointer.  This sort
 145  *              of thing is useful in exception handlers etc.
 146  */
 147
 148 extern routine flex_stackPtr;
 149
 150 /* --- flex_save --- *
 151  *
 152  * On entry:    --
 153  *
 154  * On exit:     --
 155  *
 156  * Use:         Saves some registers on the flex relocation stack.  R13
 157  *              and R14 cannot be saved -- these registers are corrupted
 158  *              during this routine's execution.
 159  *
 160  *              Values saved on the flex relocation stack are adjusted as
 161  *              flex moves blocks of memory around, so that they still point
 162  *              to the same thing as they did before.  Obviously, values
 163  *              which aren't pointers into flex blocks may be corrupted.
 164  *              Values pointing to objects deleted (either free blocks, or
 165  *              areas removed by flex_midExtend) may also be corrupted.
 166  *
 167  *              Since this routine takes no arguments, some other method has
 168  *              to be used.  The method chosen is to follow the call to
 169  *              flex_save with a LDM or STM instruction containing the
 170  *              registers to be saved.  This instruction is skipped by the
 171  *              routine, and thus not executed.
 172  *
 173  *              Note that if you give the LDM or STM the same condition code
 174  *              as the BL preceding it, it will never be executed, since
 175  *              flex_save skips it if the condition is true and it can't be
 176  *              executed if the condition is false.
 177  */
 178
 179 extern routine flex_save;
 180
 181 /* --- flex_load --- *
 182  *
 183  * On entry:    --
 184  *
 185  * On exit:     Registers loaded from relocation stack as requested
 186  *
 187  * Use:         Restores registers saved on flex's relocation stack.  See
 188  *              flex_save for calling information and details about the
 189  *              relocation stack.
 190  */
 191
 192 extern routine flex_load;
 193
 194 /*----- Useful macros -----------------------------------------------------*/
 195
 196 /* --- Macro: FSAVE --- *
 197  *
 198  * Arguments:   rList == quoted register list to save on relocation stack
 199  *
 200  * Use:         Assembles code to write the given register list on the
 201  *              flex relocation stack.  The register list should be in the
 202  *              same form as that for an STM or LDM instruction.
 203  *
 204  *              For full details about the flex relocation stack, see
 205  *              flex_save.
 206  */
 207
 208 /* --- Macro: FLOAD --- *
 209  *
 210  * Arguments:   rList == quoted register list to read from relocation stack
 211  *
 212  * Use:         Assembles code to read the given register list from the
 213  *              flex relocation stack.  The register list should be in the
 214  *              same form as that for an STM or LDM instruction.
 215  *
 216  *              For full details about the flex relocation stack, see
 217  *              flex_save.
 218  */
 219
 220 /*----- That's all, folks -------------------------------------------------*/
 221
 222 #endif