Subversion Repositories thor

#include "stdafx.h"

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

/* Subroutines in this file take care of temporary variable management */

#define SWIDTH 8

#define REGION_MAX 128  /* The maximum number of stack elements that can be

                                                                        used for temporaries. */

#define MARK    -1                      /* Marks cells that are in use but are not the

                                                                        first cell of the region */

typedef int CELL;                       /* In-use (Region) map is an array of these */

int tmpVarSpace();

void tmpFreeAll();

void tmpReset();

int tmpAlloc(int);

void tmpFree(int);

static CELL Region[REGION_MAX];

static CELL *HighWaterMark = Region;

/* ---------------------------------------------------------------------------

   Description :

      Allocate a portion of the temporary variable region of the required

        size, expanding the tmp-region size if necessary. Return the offset in

        bytes from the start of the rvalue region to the first cell of the

        temporary. 0 is returned if no space is available, and an error message is

        also printed in this situation. This way the code-generation can go on as

        if space had been found without having to worry about testing for errors.

        (Bad code is generated, but so what?)

--------------------------------------------------------------------------- */

int tmpAlloc(int size)

{

        CELL *start, *p;

        int i;

        if (size == 0)

                printf("INTERNAL, tmpAlloc: zero length region requested.\n");

        // Round size to smallest size of stack element

        //---------------------------------------------

        if (size % SWIDTH)

                size = size + SWIDTH - (size % SWIDTH);

        size /= SWIDTH;

        // Seach for an empty area big enough to contain the temp.

        //--------------------------------------------------------

        for (start = Region; start < HighWaterMark;)

        {

                for (i = size, p = start; --i >= 0 && !*p; ++p)

                        ;

                if (i >= 0)

                        start = p+1;

                else

                        break;

        }

        if (start < HighWaterMark)

                p = start;

        else

        {

                if ((HighWaterMark + size) > (Region + REGION_MAX))     // No room

                {

                        printf("Expression too complex, break into smaller pieces.\n");

                        return 0;

                }

                p = HighWaterMark;

                HighWaterMark += size;

        }

        for(*p = size; --size > 0; *++p = MARK)  /* 1st cell =size. Others = MARK) */

                ;

        return ((start - Region)*SWIDTH);

}

/* ---------------------------------------------------------------------------

   Description :

      Release a temporary var.; offset should have been returned from

   tmp_alloc().

--------------------------------------------------------------------------- */

void tmpFree(int offset)

{

        CELL *p = Region + offset/SWIDTH;

        int size;

        if (p < Region || p > HighWaterMark || !*p || *p == MARK)

                printf("INTERNAL, tmpFree: Bad offset (%d)\n", offset);

        else

                for (size = *p; --size >= 0; *p++ = 0)

                        ;

}

/* ---------------------------------------------------------------

        Description :

                Reset everything back to the virgin state, including

        the HighWater mark. This routine should be called just

        before a subroutine body is processed, when the prefix is

        output. See also: tmpFreeall().

--------------------------------------------------------------- */

void tmpReset()

{

        tmpFreeAll();

        HighWaterMark = Region;

}

/* ---------------------------------------------------------------

        Description :

                Free all temporaries currently in use (without modifying

        the high-water mark). This subroutine should be called

        after processing arithmetic statements to clean up any

        temporaries still kicking around (there is usually at least

        one).

--------------------------------------------------------------- */

void tmpFreeAll()

{

        memset(Region, 0, sizeof(Region));

}

/* ---------------------------------------------------------------

        Description :

                Return the total cumulative size of the temporary

        variable region in stack elements, not bytes. This number

        can be used as an argument to the link instruction.

        Returns :

                Size in stack elements of temporary variable area.

--------------------------------------------------------------- */

int tmpVarSpace()

{

        return (HighWaterMark - Region)*SWIDTH;

}