Subversion Repositories raptor64

#include <stdio.h>

#include <string.h>

#include "c.h"

#include "expr.h"

#include "Statement.h"

#include "gen.h"

#include "cglbdec.h"

/*

 *      68000 C compiler

 *

 *      Copyright 1984, 1985, 1986 Matthew Brandt.

 *  all commercial rights reserved.

 *

 *      This compiler is intended as an instructive tool for personal use. Any

 *      use for profit without the written consent of the author is prohibited.

 *

 *      This compiler may be distributed freely for non-commercial use as long

 *      as this notice stays intact. Please forward any enhancements or questions

 *      to:

 *

 *              Matthew Brandt

 *              Box 920337

 *              Norcross, Ga 30092

 */

/*******************************************************

        Modified to support Raptor64 'C64' language

        by Robert Finch

        robfinch@opencores.org

*******************************************************/

int InitializeType(TYP *tp);

int InitializeStructure(TYP *tp);

int initbyte();

int initchar();

int initshort();

int initlong();

int InitializePointer();

void endinit();

int InitializeArray(TYP *tp);

void doinit(SYM *sp)

{

        if (sp->storage_class == sc_static || lastst==assign) {

                seg(dataseg);          /* initialize into data segment */

                nl();                   /* start a new line in object */

        }

        else {

                seg(bssseg);            /* initialize into data segment */

                nl();                   /* start a new line in object */

        }

        if(sp->storage_class == sc_static) {

                put_label(sp->value.i);

        }

        else {

                gen_strlab(sp->name);

        }

        if( lastst != assign) {

                genstorage(sp->tp->size);

        }

        else {

                NextToken();

                InitializeType(sp->tp);

        }

    endinit();

}

int InitializeType(TYP *tp)

{

        int nbytes;

    switch(tp->type) {

        case bt_byte:

                        nbytes = initbyte();

                        break;

    case bt_char:

    case bt_enum:

            nbytes = initchar();

            break;

    case bt_short:

            nbytes = initshort();

            break;

    case bt_pointer:

            if( tp->val_flag)

                nbytes = InitializeArray(tp);

            else

                nbytes = InitializePointer();

            break;

    case bt_long:

            nbytes = initlong();

            break;

    case bt_struct:

            nbytes = InitializeStructure(tp);

            break;

    default:

        error(ERR_NOINIT);

        nbytes = 0;

    }

    return nbytes;

}

int InitializeArray(TYP *tp)

{

        int nbytes;

    char *p;

    nbytes = 0;

    if( lastst == begin) {

        NextToken();               /* skip past the brace */

        while(lastst != end) {

            nbytes += InitializeType(tp->btp);

            if( lastst == comma)

                NextToken();

            else if( lastst != end)

                error(ERR_PUNCT);

        }

        NextToken();               /* skip closing brace */

    }

    else if( lastst == sconst && tp->btp->type == bt_char) {

        nbytes = strlen(laststr) * 2 + 2;

        p = laststr;

        while( *p )

            GenerateChar(*p++);

        GenerateChar(0);

        NextToken();

    }

    else if( lastst != semicolon)

        error(ERR_ILLINIT);

    if( nbytes < tp->size) {

        genstorage( tp->size - nbytes);

        nbytes = tp->size;

    }

    else if( tp->size != 0 && nbytes > tp->size)

        error(ERR_INITSIZE);    /* too many initializers */

    return nbytes;

}

int InitializeStructure(TYP *tp)

{

        SYM *sp;

    int nbytes;

    needpunc(begin);

    nbytes = 0;

    sp = tp->lst.head;      /* start at top of symbol table */

    while(sp != 0) {

                while(nbytes < sp->value.i) {     /* align properly */

//                    nbytes += GenerateByte(0);

            GenerateByte(0);

//                    nbytes++;

                }

        nbytes += InitializeType(sp->tp);

        if( lastst == comma)

            NextToken();

        else if(lastst == end)

            break;

        else

            error(ERR_PUNCT);

        sp = sp->next;

    }

    if( nbytes < tp->size)

        genstorage( tp->size - nbytes);

    needpunc(end);

    return tp->size;

}

int initbyte()

{

        GenerateByte(GetIntegerExpression());

    return 1;

}

int initchar()

{

        GenerateChar(GetIntegerExpression());

    return 2;

}

int initshort()

{

        GenerateWord(GetIntegerExpression());

    return 4;

}

int initlong()

{

        GenerateLong(GetIntegerExpression());

    return 8;

}

int InitializePointer()

{

        SYM *sp;

    if(lastst == and) {     /* address of a variable */

        NextToken();

        if( lastst != id)

            error(ERR_IDEXPECT);

                else if( (sp = gsearch(lastid)) == NULL)

            error(ERR_UNDEFINED);

        else {

            NextToken();

            if( lastst == plus || lastst == minus)

                GenerateReference(sp,GetIntegerExpression());

            else

                GenerateReference(sp,0);

            if( sp->storage_class == sc_auto)

                    error(ERR_NOINIT);

        }

    }

    else if(lastst == sconst) {

        GenerateLabelReference(stringlit(laststr));

        NextToken();

    }

    else

        GenerateLong(GetIntegerExpression());

    endinit();

    return 8;       /* pointers are 4 bytes long */

}

void endinit()

{

        if( lastst != comma && lastst != semicolon && lastst != end) {

                error(ERR_PUNCT);

                while( lastst != comma && lastst != semicolon && lastst != end)

            NextToken();

    }

}