Subversion Repositories thor

// ============================================================================

//        __

//   \\__/ o\    (C) 2012-2018  Robert Finch, Waterloo

//    \  __ /    All rights reserved.

//     \/_//     robfinch<remove>@finitron.ca

//       ||

//

// CC64 - 'C' derived language compiler

//  - 64 bit CPU

//

// This source file is free software: you can redistribute it and/or modify 

// it under the terms of the GNU Lesser General Public License as published 

// by the Free Software Foundation, either version 3 of the License, or     

// (at your option) any later version.                                      

//                                                                          

// This source file is distributed in the hope that it will be useful,      

// but WITHOUT ANY WARRANTY; without even the implied warranty of           

// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the            

// GNU General Public License for more details.                             

//                                                                          

// You should have received a copy of the GNU General Public License        

// along with this program.  If not, see <http://www.gnu.org/licenses/>.    

//                                                                          

// ============================================================================

//

#include "stdafx.h"

#include <stdlib.h>

#include <malloc.h>

#define BLKSIZE         4000

struct blk {

        char name[8];                   // string overwrite area

    struct blk *next;

    char       m[1];           /* memory area */

};

MBlk *MBlk::first = 0;

void *allocx(int sz)

{

        return MBlk::alloc(sz);

}

void *MBlk::alloc(int sz)

{

//  dfs.printf("Enter MBlk::alloc()\n");

        MBlk *p = (MBlk *)new char[sz+sizeof(MBlk)+15];

        if (p==0)

           return p;

        ZeroMemory((void *)p,sz+sizeof(MBlk));

        p->next = first;

        first = p;

//  dfs.printf("Leave MBlk::alloc()\n");

        return &p[1];

}

void MBlk::ReleaseAll()

{

        MBlk *mbk;

        while (first) {

                mbk = first->next;

                delete[] first;

                first = mbk;

        }

}

static int      glbsize = 0,    /* size left in current global block */

                locsize = 0,    /* size left in current local block */

                glbindx = 0,    /* global index */

                locindx = 0;    /* local index */

static struct blk       *locblk = 0,    /* pointer to local block */

                        *glbblk = 0;    /* pointer to global block */

char    *xalloc(int siz)

{

        struct blk *bp;

    char       *rv;

        while(siz % 8)  // align word

                siz++;

    if( global_flag ) {

        if( glbsize >= siz ) {

            rv = &(glbblk->m[glbindx]);

            glbsize -= siz;

            glbindx += siz;

            return (rv);

        }

        else {

            bp = (struct blk *)calloc(1,sizeof(struct blk) + BLKSIZE);

                        if( bp == (struct blk *)NULL )

                        {

                                printf(" not enough memory.\n");

                                exit(1);

                        }

                        strcpy_s(bp->name,8,"C64    ");

            bp->next = glbblk;

            glbblk = bp;

            glbsize = BLKSIZE - siz;

            glbindx = siz;

            return (glbblk->m);

        }

    }

    else    {

        if( locsize >= siz ) {

            rv = &(locblk->m[locindx]);

            locsize -= siz;

            locindx += siz;

            return (rv);

        }

        else {

            bp = (struct blk *)calloc(1,sizeof(struct blk) + BLKSIZE);

                        if( bp == NULL )

                        {

                                printf(" not enough local memory.\n");

                                exit(1);

                        }

                        strcpy_s(bp->name,8,"C64    ");

            bp->next = locblk;

            locblk = bp;

            locsize = BLKSIZE - siz;

            locindx = siz;

            return (locblk->m);

        }

    }

}

void ReleaseLocalMemory()

{

        struct blk      *bp1, *bp2;

    int             blkcnt;

    blkcnt = 0;

    bp1 = locblk;

    while( bp1 != NULL ) {

                if (strcmp(bp1->name,"C64    "))

                        printf("Block corrupted.");

        bp2 = bp1->next;

        free( bp1 );

        ++blkcnt;

        bp1 = bp2;

    }

    locblk = (struct blk *)NULL;

    locsize = 0;

        currentStmt = (Statement *)NULL;

        if (verbose) printf(" releasing %d bytes local tables.\n",blkcnt * BLKSIZE);

}

void ReleaseGlobalMemory()

{

        struct blk      *bp1, *bp2;

  int             blkcnt;

  dfs.printf("Enter ReleaseGlobalMemory\n");

  bp1 = glbblk;

  blkcnt = 0;

  while( bp1 != (struct blk *)NULL ) {

                if (strcmp(bp1->name,"C64    "))

                  dfs.printf("Block corrupted.");

    bp2 = bp1->next;

    free(bp1);

    ++blkcnt;

    bp1 = bp2;

  }

  glbblk = (struct blk *)NULL;

  glbsize = 0;

//    gsyms.head = NULL;         /* clear global symbol table */

//      gsyms.tail = NULL;

        memset(gsyms,0,sizeof(gsyms));

        if (verbose) printf(" releasing %d bytes global tables.\n",blkcnt * BLKSIZE);

    strtab = (struct slit *)NULL;             /* clear literal table */

 dfs.printf("Leave ReleaseGlobalMemory\n");

}

SYM *allocSYM() {

        SYM *sym = (SYM *)&compiler.symbolTable[compiler.symnum];

        ZeroMemory(sym,sizeof(SYM));

        sym->id = compiler.symnum;

        sym->name = new std::string("");

        sym->name2 = new std::string("");

        sym->name3 = new std::string("");

        sym->shortname = new std::string("");

        sym->lsyms.SetOwner(compiler.symnum);

        compiler.symnum++;

        if (compiler.symnum > 32760) {

          dfs.printf("Too many symbols.\n");

    throw new C64PException(ERR_TOOMANY_SYMBOLS,1);

  }

        return sym;

};

Function *allocFunction(int symnum)

{

        int count;

        for (count = 0; count < 3000; count++) {

                Function *sym = &compiler.functionTable[compiler.funcnum];

                if (!sym->valid) {

                        ZeroMemory(sym, sizeof(Function));

                        sym->valid = TRUE;

                        sym->params.SetOwner(symnum);

                        sym->proto.SetOwner(symnum);

                        sym->UsesTemps = true;

                        sym->UsesStackParms = true;

                        compiler.funcnum++;

                        if (compiler.funcnum > 2999)

                                compiler.funcnum = 0;

                        return (sym);

                }

                compiler.funcnum++;

                if (compiler.funcnum > 2999)

                        compiler.funcnum = 0;

        }

        dfs.printf("Too many functions.\n");

        throw new C64PException(ERR_TOOMANY_SYMBOLS, 1);

};

void FreeFunction(Function *fn)

{

        fn->valid = FALSE;

}

TYP *allocTYP()

{

//  printf("allocTYP()\r\n");

        TYP *tp = (TYP *)&compiler.typeTable[compiler.typenum];

        ZeroMemory(tp,sizeof(TYP));

        tp->sname = new std::string("");

  tp->bit_width = -1;

//      printf("Leave allocTYP():%p\r\n",tp);

  compiler.typenum++;

        if (compiler.typenum > 32760) {

          dfs.printf("Too many types\n");

    throw new C64PException(ERR_TOOMANY_SYMBOLS,1);

  }

        return tp;

};

Statement *allocSnode() { return (Statement *)xalloc(sizeof(Statement)); };

ENODE *allocEnode() {

  ENODE *p;

  p = (ENODE *)allocx(sizeof(ENODE));

  ZeroMemory(p, sizeof(ENODE));

  p->sp = new std::string();

  return (p);

};

Operand *allocOperand() { return (Operand *)xalloc(sizeof(Operand)); };

CSE *allocCSE() { return (CSE *)xalloc(sizeof(CSE)); };