URL https://opencores.org/ocsvn/raptor64/raptor64/trunk

Subversion Repositories raptor64

[/] [raptor64/] [trunk/] [software/] [c64/] [source/] [ParseExpressions.c] - Blame information for rev 51

Details | Compare with Previous | View Log


#include        <stdio.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
*******************************************************/
 
TYP             stdint = { bt_long, bt_long, 0, FALSE, FALSE, FALSE, 0,0,8, {0, 0}, 0, 0 };
TYP             stduint = { bt_long, bt_long, 0, TRUE, FALSE, FALSE, 0,0,8, {0, 0}, 0, 0 };
TYP             stdlong = { bt_long, bt_long, 0, FALSE, FALSE, FALSE, 0,0,8, {0, 0}, 0, 0 };
TYP             stdulong = { bt_long, bt_long, 0, TRUE, FALSE, FALSE, 0,0,8, {0, 0}, 0, 0 };
TYP             stdshort = { bt_short, bt_short, 0, FALSE, FALSE, FALSE, 0,0,4, {0, 0}, 0, 0 };
TYP             stdushort = { bt_short, bt_short, 0, TRUE, FALSE, FALSE, 0,0,4, {0, 0}, 0, 0 };
TYP             stdchar = {bt_char, bt_char, 0, FALSE, FALSE, FALSE, 0,0,2, {0, 0}, 0, 0 };
TYP             stduchar = {bt_char, bt_char, 0, TRUE, FALSE, FALSE, 0,0,2, {0, 0}, 0, 0 };
TYP             stdbyte = {bt_byte, bt_byte, 0, FALSE, FALSE, FALSE, 0,0,1, {0, 0}, 0, 0 };
TYP             stdubyte = {bt_byte, bt_byte, 0, TRUE, FALSE, FALSE, 0,0,1, {0, 0}, 0, 0 };
TYP             stdstring = {bt_pointer, bt_pointer, 1, FALSE, FALSE, FALSE, 0,0,4, {0, 0}, &stdchar, 0};
TYP             stdfunc = {bt_func, bt_func, 1, FALSE, FALSE, FALSE, 0,0,0, {0, 0}, &stdint, 0};
extern TYP      *head;          /* shared with ParseSpecifier */
extern TYP      *tail;
 
/*
 *      expression evaluation
 *
 *      this set of routines builds a parse tree for an expression.
 *      no code is generated for the expressions during the build,
 *      this is the job of the codegen module. for most purposes
 *      expression() is the routine to call. it will allow all of
 *      the C operators. for the case where the comma operator is
 *      not valid (function parameters for instance) call NonCommaExpression().
 *
 *      each of the routines returns a pointer to a describing type
 *      structure. each routine also takes one parameter which is a
 *      pointer to an expression node by reference (address of pointer).
 *      the completed expression is returned in this pointer. all
 *      routines return either a pointer to a valid type or NULL if
 *      the hierarchy of the next operator is too low or the next
 *      symbol is not part of an expression.
 */
 
TYP     *expression();  /* forward ParseSpecifieraration */
TYP     *NonCommaExpression();      /* forward ParseSpecifieraration */
TYP     *ParseUnaryExpression();       /* forward ParseSpecifieraration */
 
/*
 *      build an expression node with a node type of nt and values
 *      v1 and v2.
 */
ENODE *makenode(int nt, ENODE *v1, ENODE *v2)
{
        ENODE *ep;
    ep = (ENODE *)xalloc(sizeof(ENODE));
    ep->nodetype = nt;
    ep->constflag = FALSE;
        ep->etype = bt_void;
        ep->esize = -1;
        ep->p[0] = v1;
        ep->p[1] = v2;
    return ep;
}
 
ENODE *makesnode(int nt, char *v1)
{
        ENODE *ep;
    ep = (ENODE *)xalloc(sizeof(ENODE));
    ep->nodetype = nt;
    ep->constflag = FALSE;
        ep->etype = bt_void;
        ep->esize = -1;
        ep->sp = v1;
    return ep;
}
 
ENODE *makenodei(int nt, ENODE *v1, __int64 i)
{
        ENODE *ep;
    ep = (ENODE *)xalloc(sizeof(ENODE));
    ep->nodetype = nt;
    ep->constflag = FALSE;
        ep->etype = bt_void;
        ep->esize = -1;
        ep->i = i;
        ep->p[0] = v1;
        ep->p[1] = NULL;
    return ep;
}
 
ENODE *makeinode(int nt, __int64 v1)
{
        ENODE *ep;
    ep = (ENODE *)xalloc(sizeof(ENODE));
    ep->nodetype = nt;
    ep->constflag = TRUE;
        ep->etype = bt_void;
        ep->esize = -1;
    ep->i = v1;
    return ep;
}
 
void PromoteConstFlag(ENODE *ep)
{
        ep->constflag = ep->p[0]->constflag && ep->p[1]->constflag;
}
 
/*
 *      build the proper dereference operation for a node using the
 *      type pointer tp.
 */
TYP *deref(ENODE **node, TYP *tp)
{
        switch( tp->type ) {
                case bt_byte:
                        if (tp->isUnsigned)
                                *node = makenode(en_ub_ref,*node,NULL);
                        else
                                *node = makenode(en_b_ref,*node,NULL);
                        (*node)->esize = tp->size;
                        (*node)->etype = tp->type;
            tp = &stdint;
            break;
                case bt_char:
        case bt_enum:
                        if (tp->isUnsigned)
                                *node = makenode(en_uc_ref,*node,NULL);
                        else
                                *node = makenode(en_c_ref,*node,NULL);
                        (*node)->esize = tp->size;
                        (*node)->etype = tp->type;
            tp = &stdchar;
            break;
        case bt_short:
            *node = makenode(en_h_ref,*node,NULL);
                        (*node)->esize = tp->size;
                        (*node)->etype = tp->type;
            tp = &stdint;
            break;
                case bt_long:
                case bt_pointer:
                case bt_unsigned:
                        (*node)->esize = tp->size;
                        (*node)->etype = tp->type;
            *node = makenode(en_w_ref,*node,NULL);
            break;
                case bt_bitfield:
                        if (tp->isUnsigned){
                                if (tp->size==1)
                                        *node = makenode(en_ubfieldref, *node, NULL);
                                else if (tp->size==2)
                                        *node = makenode(en_ucfieldref, *node, NULL);
                                else if (tp->size==4)
                                        *node = makenode(en_uhfieldref, *node, NULL);
                                else
                                        *node = makenode(en_wfieldref, *node, NULL);
                        }
                        else {
                                if (tp->size==1)
                                        *node = makenode(en_bfieldref, *node, NULL);
                                else if (tp->size==2)
                                        *node = makenode(en_cfieldref, *node, NULL);
                                else if (tp->size==4)
                                        *node = makenode(en_hfieldref, *node, NULL);
                                else
                                        *node = makenode(en_wfieldref, *node, NULL);
                        }
                        (*node)->bit_width = tp->bit_width;
                        (*node)->bit_offset = tp->bit_offset;
                        /*
                        * maybe it should be 'unsigned'
                        */
                        (*node)->etype = stdint.type;
                        (*node)->esize = tp->size;
                        tp = &stdint;
                        break;
                default:
                        error(ERR_DEREF);
                        break;
    }
    return tp;
}
 
/*
 *      nameref will build an expression tree that references an
 *      identifier. if the identifier is not in the global or
 *      local symbol table then a look-ahead to the next character
 *      is done and if it indicates a function call the identifier
 *      is coerced to an external function name. non-value references
 *      generate an additional level of indirection.
 */
TYP *nameref(ENODE **node)
{
        SYM             *sp;
    TYP             *tp;
        char stnm[200];
    sp = gsearch(lastid);
    if( sp == NULL ) {
        while( isspace(lastch) )
            getch();
        if( lastch == '(') {
            ++global_flag;
            sp = allocSYM();
            sp->tp = &stdfunc;
            sp->name = litlate(lastid);
            sp->storage_class = sc_external;
            insert(sp,&gsyms);
            --global_flag;
            tp = &stdfunc;
            *node = makesnode(en_nacon,sp->name);
            (*node)->constflag = TRUE;
        }
        else {
            tp = NULL;
            error(ERR_UNDEFINED);
        }
    }
    else    {
            if( (tp = sp->tp) == NULL ) {
                error(ERR_UNDEFINED);
                return NULL;       /* guard against untyped entries */
            }
            switch( sp->storage_class ) {
                    case sc_static:
                                                if (sp->tp->type==bt_func || sp->tp->type==bt_ifunc) {
                                                                strcpy(stnm,GetNamespace());
                                                                strcat(stnm,"_");
                                                                strcat(stnm,sp->name);
                                                                *node = makesnode(en_nacon,litlate(stnm));
                                                                (*node)->constflag = TRUE;
                                                                //*node = makesnode(en_nacon,sp->name);
                                                                //(*node)->constflag = TRUE;
                                                        }
                                                        else {
                                                                *node = makeinode(en_labcon,sp->value.i);
                                                                (*node)->constflag = TRUE;
                                                        }
                            break;
                    case sc_global:
                    case sc_external:
                            *node = makesnode(en_nacon,sp->name);
                            (*node)->constflag = TRUE;
                            break;
                    case sc_const:
                            *node = makeinode(en_icon,sp->value.i);
                            (*node)->constflag = TRUE;
                            break;
                    default:        /* auto and any errors */
                            if( sp->storage_class != sc_auto)
                                    error(ERR_ILLCLASS);
                            *node = makeinode(en_autocon,sp->value.i);
                            break;
                    }
            if( tp->val_flag == FALSE)
                    tp = deref(node,tp);
            }
    NextToken();
    return tp;
}
 
/*
 *      ArgumentList will build a list of parameter expressions in
 *      a function call and return a pointer to the last expression
 *      parsed. since parameters are generally pushed from right
 *      to left we get just what we asked for...
 */
ENODE *ArgumentList()
{
        struct ENODE    *ep1, *ep2;
    ep1 = 0;
    while( lastst != closepa)
        {
        NonCommaExpression(&ep2);          /* evaluate a parameter */
        ep1 = makenode(en_void,ep2,ep1);
        if( lastst != comma)
            break;
        NextToken();
    }
    return ep1;
}
 
/*
 *      return 1 if st in set of [ kw_char, kw_short, kw_long, kw_int,
 *      kw_float, kw_double, kw_struct, kw_union ]
 */
static int IsIntrinsicType(int st)
{
        return  st == kw_byte || st==kw_char || st == kw_short || st == kw_int || st==kw_void ||
                st == kw_long || st == kw_float || st == kw_double || st==kw_enum ||
                st == kw_struct || st == kw_union || st== kw_unsigned || st==kw_signed;
}
 
int IsBeginningOfTypecast(int st)
{
        SYM *sp;
        if (st==id) {
                sp = search(lastid,&gsyms[0]);
                if (sp)
                        return sp->storage_class==sc_typedef;
                return FALSE;
        }
        else
                return IsIntrinsicType(st);
}
 
/*
 *      primary will parse a primary expression and set the node pointer
 *      returning the type of the expression parsed. primary expressions
 *      are any of:
 *                      id
 *                      constant
 *                      string
 *                      ( expression )
 *                      primary[ expression ]
 *                      primary.id
 *                      primary->id
 *                      primary( parameter list )
 */
TYP *ParsePrimaryExpression(ENODE **node)
{
        ENODE    *pnode, *qnode, *rnode, *snode, *rnode1, *pnode1, *qnode1, *qnode2;
        __int64 i ;
        int sza[10];
        int brcount;
        SYM             *sp;
        TYP             *tptr;
                brcount = 0;
                qnode1 = NULL;
                qnode2 = NULL;
        switch( lastst ) {
 
                case id:
                        tptr = nameref(&pnode);
                        break;
                case iconst:
                        tptr = &stdint;
                        pnode = makeinode(en_icon,ival);
                        pnode->constflag = TRUE;
                        NextToken();
                        break;
                case sconst:
                        tptr = &stdstring;
                        pnode = makenodei(en_labcon,NULL,stringlit(laststr));
                        pnode->constflag = TRUE;
                        NextToken();
                        break;
 
                case openpa:
                        NextToken();
                        if( !IsBeginningOfTypecast(lastst) ) {
                            tptr = expression(&pnode);
                            needpunc(closepa);
                        }
                        else {                  /* cast operator */
                            ParseSpecifier(0); /* do cast ParseSpecifieraration */
                            ParseDeclarationPrefix(FALSE);
                            tptr = head;
                            needpunc(closepa);
                            if( ParseUnaryExpression(&pnode) == NULL ) {
                                error(ERR_IDEXPECT);
                                tptr = NULL;
                            }
                        }
                        break;
 
                default:
                        return NULL;
                }
        for(;;) {
                switch( lastst ) {
                        case openbr:    /* build a subscript reference */
                                                        brcount++;
                                                        if (tptr==NULL) {
                                                                error(ERR_UNDEFINED);
                                                                goto fini;
                                                        }
                                if( tptr->type != bt_pointer )
                                        error(ERR_NOPOINTER);
                                else
                                        tptr = tptr->btp;
                                NextToken();
                                                                if (tptr->val_flag && (tptr->size==1 || tptr->size==2 || tptr->size==4 || tptr->size==8)) {
                                                                        expression(&rnode);
                                                                        pnode = makenode(en_add,rnode,pnode);
                                                                        pnode->constflag = rnode->constflag && pnode->p[1]->constflag;
                                                                        pnode->scale = tptr->size;
                                                                }
                                                                else {
                                                                        sza[brcount-1] = tptr->size;
                                                                        qnode = makeinode(en_icon,tptr->size);
                                                                        // swap sizes for array indexing
                                                                        if (brcount==3) {
                                                                                qnode->i = sza[0];
                                                                                qnode2->i = sza[1];
                                                                                qnode1->i = sza[2];
                                                                        }
                                                                        else if (brcount==2) {
                                                                                qnode->i = sza[0];
                                                                                qnode1->i = sza[1];
                                                                        }
                                                                        if (qnode1==NULL)
                                                                                qnode1 = qnode;
                                                                        else
                                                                                qnode2 = qnode;
                                                                        qnode->constflag = TRUE;
                                                                        expression(&rnode);
                                                                        needpunc(closebr);
        /*
 *      we could check the type of the expression here...
 */
                                                                        qnode = makenode(en_mulu,qnode,rnode);
                                                                        qnode->constflag = rnode->constflag && qnode->p[0]->constflag;
                                                                        pnode = makenode(en_add,qnode,pnode);
                                                                        pnode->constflag = qnode->constflag && pnode->p[1]->constflag;
                                                                        pnode->scale = 1;
                                                                        //if( tptr->val_flag == 0 )
                                                                        //      tptr = deref(&pnode,tptr);
                                                                }
                                ////snode = makenode(en_mul,qnode,rnode);
                                ////snode->constflag = rnode->constflag && snode->p[0]->constflag;
                                ////pnode = makenode(en_add,snode,pnode);
                                ////pnode->constflag = snode->constflag && pnode->p[1]->constflag;
                                if( tptr->val_flag == FALSE )
                                    tptr = deref(&pnode,tptr);
//                                needpunc(closebr);
                                break;
 
                        case pointsto:
                                                        if (tptr==NULL) {
                                                                error(ERR_UNDEFINED);
                                                                goto fini;
                                                        }
                            if( tptr->type != bt_pointer )
                                error(ERR_NOPOINTER);
                            else
                                tptr = tptr->btp;
                            if( tptr->val_flag == FALSE )
                                pnode = makenode(en_w_ref,pnode,NULL);
/*
 *      fall through to dot operation
 */
                        case dot:
                                NextToken();       /* past -> or . */
                                if( lastst != id )
                                        error(ERR_IDEXPECT);
                                else    {
                                        sp = search(lastid,&tptr->lst);
                                        if( sp == NULL )
                                            error(ERR_NOMEMBER);
                                        else {
                                            tptr = sp->tp;
                                            qnode = makeinode(en_icon,sp->value.i);
                                            qnode->constflag = TRUE;
                                            pnode = makenode(en_add,pnode,qnode);
                                            pnode->constflag = pnode->p[0]->constflag;
                                            if( tptr->val_flag == FALSE )
                                                tptr = deref(&pnode,tptr);
                                        }
                                        NextToken();       /* past id */
                                        }
                                break;
 
                        case openpa:    /* function reference */
                                NextToken();
                                if( tptr->type != bt_func && tptr->type != bt_ifunc )
                                    error(ERR_NOFUNC);
                                else
                                    tptr = tptr->btp;
                                                                currentFn->IsLeaf = FALSE;
                                pnode = makenode(en_fcall,pnode,ArgumentList());
                                needpunc(closepa);
                                break;
 
                        default:
                                goto fini;
                        }
                }
fini:   *node = pnode;
        return tptr;
}
 
/*
 *      this function returns true if the node passed is an IsLValue.
 *      this can be qualified by the fact that an IsLValue must have
 *      one of the dereference operators as it's top node.
 */
int IsLValue(ENODE *node)
{
        switch( node->nodetype ) {
    case en_b_ref:
        case en_c_ref:
        case en_h_ref:
    case en_w_ref:
        case en_ub_ref:
        case en_uc_ref:
        case en_uh_ref:
    case en_uw_ref:
        case en_wfieldref:
        case en_uwfieldref:
        case en_bfieldref:
        case en_ubfieldref:
        case en_cfieldref:
        case en_ucfieldref:
        case en_hfieldref:
        case en_uhfieldref:
            return TRUE;
        case en_cbc:
        case en_cbh:
    case en_cbw:
        case en_cch:
        case en_ccw:
        case en_chw:
            return IsLValue(node->p[0]);
    }
    return FALSE;
}
 
/*
 *      ParseUnaryExpression evaluates unary expressions and returns the type of the
 *      expression evaluated. unary expressions are any of:
 *
 *                      primary
 *                      primary++
 *                      primary--
 *                      !unary
 *                      ~unary
 *                      ++unary
 *                      --unary
 *                      -unary
 *                      *unary
 *                      &unary
 *                      (typecast)unary
 *                      sizeof(typecast)
 *                      typenum(typecast)
 *
 */
TYP *ParseUnaryExpression(ENODE **node)
{
        TYP *tp, *tp1;
    ENODE *ep1, *ep2;
    int flag;
        __int64 i;
 
        flag = 0;
        switch( lastst ) {
                case autodec:
                        flag = 1;
                /* fall through to common increment */
                case autoinc:
                        NextToken();
                        tp = ParseUnaryExpression(&ep1);
                        if( tp == NULL ) {
                            error(ERR_IDEXPECT);
                            return NULL;
                        }
                        if( IsLValue(ep1)) {
                            if( tp->type == bt_pointer )
                                ep2 = makeinode(en_icon,tp->btp->size);
                            else
                                ep2 = makeinode(en_icon,1);
                            ep2->constflag = TRUE;
                            ep1 = makenode(flag ? en_assub : en_asadd,ep1,ep2);
                        }
                        else
                            error(ERR_LVALUE);
                        break;
 
                case minus:
                        NextToken();
                        tp = ParseUnaryExpression(&ep1);
                        if( tp == NULL ) {
                            error(ERR_IDEXPECT);
                            return NULL;
                        }
                        ep1 = makenode(en_uminus,ep1,NULL);
                        ep1->constflag = ep1->p[0]->constflag;
                        break;
 
                case not:
                        NextToken();
                        tp = ParseUnaryExpression(&ep1);
                        if( tp == NULL ) {
                            error(ERR_IDEXPECT);
                            return NULL;
                        }
                        ep1 = makenode(en_not,ep1,NULL);
                        ep1->constflag = ep1->p[0]->constflag;
                        break;
 
                case compl:
                        NextToken();
                        tp = ParseUnaryExpression(&ep1);
                        if( tp == NULL ) {
                            error(ERR_IDEXPECT);
                            return 0;
                        }
                        ep1 = makenode(en_compl,ep1,NULL);
                        ep1->constflag = ep1->p[0]->constflag;
                        break;
 
                case star:
                        NextToken();
                        tp = ParseUnaryExpression(&ep1);
                        if( tp == NULL ) {
                            error(ERR_IDEXPECT);
                            return NULL;
                        }
                        if( tp->btp == NULL )
                                                        error(ERR_DEREF);
                        else
                            tp = tp->btp;
                        if( tp->val_flag == FALSE )
                                                        tp = deref(&ep1,tp);
                        break;
 
                case and:
                        NextToken();
                        tp = ParseUnaryExpression(&ep1);
                        if( tp == NULL ) {
                            error(ERR_IDEXPECT);
                            return NULL;
                        }
                        if( IsLValue(ep1))
                                ep1 = ep1->p[0];
                        tp1 = allocTYP();
                        tp1->size = 8;
                        tp1->type = bt_pointer;
                        tp1->btp = tp;
                        tp1->val_flag = FALSE;
                        tp1->lst.head = NULL;
                        tp1->sname = NULL;
                        tp = tp1;
                        break;
 
                case kw_sizeof:
                        NextToken();
                        needpunc(openpa);
                                                tp = head;
                                                tp1 = tail;
                        ParseSpecifier(0);
                        ParseDeclarationPrefix(FALSE);
                        if( head != NULL )
                            ep1 = makeinode(en_icon,head->size);
                                                else {
                            error(ERR_IDEXPECT);
                            ep1 = makeinode(en_icon,1);
                        }
                                                head = tp;
                                                tail = tp1;
                        ep1->constflag = TRUE;
                        tp = &stdint;
                        needpunc(closepa);
                        break;
 
                case kw_typenum:
                        NextToken();
                        needpunc(openpa);
                                                tp = head;
                                                tp1 = tail;
                        ParseSpecifier(0);
                        ParseDeclarationPrefix(FALSE);
                        if( head != NULL )
                            ep1 = makeinode(en_icon,GetTypeHash(head));
                                                else {
                            error(ERR_IDEXPECT);
                            ep1 = makeinode(en_icon,1);
                        }
                                                head = tp;
                                                tail = tp1;
                        ep1->constflag = TRUE;
                        tp = &stdint;
                        needpunc(closepa);
                        break;
 
                default:
                        tp = ParsePrimaryExpression(&ep1);
                        if( tp != NULL ) {
                                if( tp->type == bt_pointer )
                                        i = tp->btp->size;
                                else
                                        i = 1;
                                if( lastst == autoinc) {
                                                                        if( IsLValue(ep1) ) {
                                                                                if (tp->type == bt_pointer)
                                                                                        ep2 = makeinode(en_icon,tp->btp->size);
                                                                                else
                                                                                        ep2 = makeinode(en_icon,1);
                                                                                ep2->constflag = TRUE;
                                                                                ep1 = makenode(en_asadd,ep1,ep2);
//                                        ep1 = makenodei(en_ainc,ep1,i);
                                                                        }
                                    else
                                        error(ERR_LVALUE);
                                    NextToken();
                                }
                                else if( lastst == autodec ) {
                                                                        if( IsLValue(ep1) ) {
                                                                                if (tp->type == bt_pointer)
                                                                                        ep2 = makeinode(en_icon,tp->btp->size);
                                                                                else
                                                                                        ep2 = makeinode(en_icon,1);
                                                                                ep2->constflag = TRUE;
                                                                                ep1 = makenode(en_assub,ep1,ep2);
//                                                ep1 = makenodei(en_adec,ep1,i);
                                                                                }
                                        else
                                                error(ERR_LVALUE);
                                        NextToken();
                                        }
                                }
                        break;
                }
        *node = ep1;
        return tp;
}
 
/*
 *      forcefit will coerce the nodes passed into compatable
 *      types and return the type of the resulting expression.
 */
TYP     *forcefit(ENODE **node1,TYP *tp1,ENODE **node2,TYP *tp2)
{
        switch( tp1->type ) {
                case bt_char:
                case bt_uchar:
                                        if (tp2->type == bt_long) {
                                                if (tp1->isUnsigned)
                                                        return &stdulong;
                                                else
                                                        return &stdlong;
                                        }
                                        if (tp2->type == bt_short) {
                                                if (tp1->isUnsigned)
                                                        return &stdushort;
                                                else
                                                        return &stdshort;
                                        }
                                        if (tp2->type == bt_pointer)
                                                return tp2;
                                        return tp1;     // char
                case bt_short:
                case bt_ushort:
                                        if (tp2->type == bt_long) {
                                                if (tp1->isUnsigned)
                                                        return &stdulong;
                                                else
                                                        return &stdlong;
                                        }
                                        if (tp2->type == bt_pointer)
                                                return tp2;
                                        return tp1;
                case bt_long:
                case bt_ulong:
                        if( tp2->type == bt_pointer     )
                                                        return tp2;
                                                return tp1;
                case bt_pointer:
                        if( isscalar(tp2) || tp2->type == bt_pointer)
                                return tp1;
                        break;
                case bt_unsigned:
                        if( tp2->type == bt_pointer )
                                return tp2;
                        else if( isscalar(tp2) )
                                return tp1;
                        break;
                }
        error( ERR_MISMATCH );
        return tp1;
}
 
/*
 *      this function returns true when the type of the argument is
 *      one of char, short, unsigned, or long.
 */
int     isscalar(TYP *tp)
{
        return
                        tp->type == bt_byte ||
                        tp->type == bt_char ||
            tp->type == bt_short ||
            tp->type == bt_long ||
                        tp->type == bt_uchar ||
            tp->type == bt_ushort ||
            tp->type == bt_ulong ||
            tp->type == bt_unsigned;
}
 
/*
 *      multops parses the multiply priority operators. the syntax of
 *      this group is:
 *
 *              unary
 *              multop * unary
 *              multop / unary
 *              multop % unary
 */
TYP *multops(struct ENODE **node)
{
        struct ENODE    *ep1, *ep2;
        TYP             *tp1, *tp2;
        int                   oper;
        tp1 = ParseUnaryExpression(&ep1);
        if( tp1 == 0 )
                return 0;
        while( lastst == star || lastst == divide || lastst == modop ) {
                oper = lastst;
                NextToken();       /* move on to next unary op */
                tp2 = ParseUnaryExpression(&ep2);
                if( tp2 == 0 ) {
                        error(ERR_IDEXPECT);
                        *node = ep1;
                        return tp1;
                        }
                tp1 = forcefit(&ep1,tp1,&ep2,tp2);
                switch( oper ) {
                        case star:
                                if( tp1->isUnsigned )
                                        ep1 = makenode(en_mulu,ep1,ep2);
                                else
                                        ep1 = makenode(en_mul,ep1,ep2);
                                break;
                        case divide:
                                if( tp1->isUnsigned )
                                        ep1 = makenode(en_udiv,ep1,ep2);
                                else
                                        ep1 = makenode(en_div,ep1,ep2);
                                break;
                        case modop:
                                if( tp1->isUnsigned )
                                        ep1 = makenode(en_umod,ep1,ep2);
                                else
                                        ep1 = makenode(en_mod,ep1,ep2);
                                break;
                        }
                PromoteConstFlag(ep1);
                }
        *node = ep1;
        return tp1;
}
 
/*
 *      addops handles the addition and subtraction operators.
 */
TYP     *addops(ENODE **node)
{
        ENODE    *ep1, *ep2, *ep3;
    TYP             *tp1, *tp2;
    int             oper;
 
        tp1 = multops(&ep1);
    if( tp1 == NULL )
        return NULL;
    while( lastst == plus || lastst == minus ) {
            oper = (lastst == plus);
            NextToken();
            tp2 = multops(&ep2);
            if( tp2 == 0 ) {
                    error(ERR_IDEXPECT);
                    *node = ep1;
                    return tp1;
                    }
            if( tp1->type == bt_pointer ) {
                    tp2 = forcefit(0,&stdint,&ep2,tp2);
                    ep3 = makeinode(en_icon,tp1->btp->size);
                    ep3->constflag = TRUE;
                    ep2 = makenode(en_mulu,ep3,ep2);
                    ep2->constflag = ep2->p[1]->constflag;
                    }
            else if( tp2->type == bt_pointer ) {
                    tp1 = forcefit(0,&stdint,&ep1,tp1);
                    ep3 = makeinode(en_icon,tp2->btp->size);
                    ep3->constflag = TRUE;
                    ep1 = makenode(en_mulu,ep3,ep1);
                    ep1->constflag = ep1->p[1]->constflag;
                    }
            tp1 = forcefit(&ep1,tp1,&ep2,tp2);
            ep1 = makenode( oper ? en_add : en_sub,ep1,ep2);
            PromoteConstFlag(ep1);
            }
    *node = ep1;
    return tp1;
}
 
/*
 *      shiftop handles the shift operators << and >>.
 */
TYP     *shiftop(ENODE **node)
{
        struct ENODE    *ep1, *ep2;
        TYP             *tp1, *tp2;
        int             oper;
        tp1 = addops(&ep1);
        if( tp1 == 0)
                return 0;
        while( lastst == lshift || lastst == rshift) {
                oper = (lastst == lshift);
                NextToken();
                tp2 = addops(&ep2);
                if( tp2 == 0 )
                        error(ERR_IDEXPECT);
                else    {
                        tp1 = forcefit(&ep1,tp1,&ep2,tp2);
                                                if (tp1->isUnsigned)
                                                        ep1 = makenode(oper ? en_shl : en_shru,ep1,ep2);
                                                else
                                                        ep1 = makenode(oper ? en_shl : en_shr,ep1,ep2);
                                PromoteConstFlag(ep1);
                        }
                }
        *node = ep1;
        return tp1;
}
 
/*
 *      relation handles the relational operators < <= > and >=.
 */
TYP     *relation(ENODE **node)
{       struct ENODE    *ep1, *ep2;
        TYP             *tp1, *tp2;
        int             nt;
        tp1 = shiftop(&ep1);
        if( tp1 == 0 )
                return 0;
        for(;;) {
                switch( lastst ) {
 
                        case lt:
                                if( tp1->isUnsigned )
                                        nt = en_ult;
                                else
                                        nt = en_lt;
                                break;
                        case gt:
                                if( tp1->isUnsigned )
                                        nt = en_ugt;
                                else
                                        nt = en_gt;
                                break;
                        case leq:
                                if( tp1->isUnsigned )
                                        nt = en_ule;
                                else
                                        nt = en_le;
                                break;
                        case geq:
                                if( tp1->isUnsigned )
                                        nt = en_uge;
                                else
                                        nt = en_ge;
                                break;
                        default:
                                goto fini;
                        }
                NextToken();
                tp2 = shiftop(&ep2);
                if( tp2 == 0 )
                        error(ERR_IDEXPECT);
                else    {
                        tp1 = forcefit(&ep1,tp1,&ep2,tp2);
                        ep1 = makenode(nt,ep1,ep2);
                                PromoteConstFlag(ep1);
                        }
                }
fini:   *node = ep1;
        return tp1;
}
 
/*
 *      equalops handles the equality and inequality operators.
 */
TYP     *equalops(ENODE **node)
{
        ENODE    *ep1, *ep2;
    TYP             *tp1, *tp2;
    int             oper;
    tp1 = relation(&ep1);
    if( tp1 == NULL )
            return NULL;
    while( lastst == eq || lastst == neq ) {
        oper = (lastst == eq);
        NextToken();
        tp2 = relation(&ep2);
        if( tp2 == NULL )
                error(ERR_IDEXPECT);
        else {
            tp1 = forcefit(&ep1,tp1,&ep2,tp2);
            ep1 = makenode( oper ? en_eq : en_ne,ep1,ep2);
            PromoteConstFlag(ep1);
        }
        }
    *node = ep1;
    return tp1;
}
 
/*
 *      binop is a common routine to handle all of the legwork and
 *      error checking for bitand, bitor, bitxor, andop, and orop.
 */
TYP *binop(ENODE **node, TYP *(*xfunc)(),int nt, int sy)
{
        ENODE    *ep1, *ep2;
        TYP             *tp1, *tp2;
        tp1 = (*xfunc)(&ep1);
        if( tp1 == 0 )
                return 0;
        while( lastst == sy ) {
                NextToken();
                tp2 = (*xfunc)(&ep2);
                if( tp2 == 0 )
                        error(ERR_IDEXPECT);
                else    {
                        tp1 = forcefit(&ep1,tp1,&ep2,tp2);
                        ep1 = makenode(nt,ep1,ep2);
                                PromoteConstFlag(ep1);
                        }
                }
        *node = ep1;
        return tp1;
}
 
TYP     *bitand(ENODE **node)
/*
 *      the bitwise and operator...
 */
{       return binop(node,equalops,en_and,and);
}
 
TYP     *bitxor(ENODE **node)
{       return binop(node,bitand,en_xor,uparrow);
}
 
TYP     *bitor(ENODE **node)
{       return binop(node,bitxor,en_or,or);
}
 
TYP     *andop(ENODE **node)
{       return binop(node,bitor,en_land,land);
}
 
TYP *orop(ENODE **node)
{
        return binop(node,andop,en_lor,lor);
}
 
/*
 *      this routine processes the hook operator.
 */
TYP *conditional(ENODE **node)
{
        TYP             *tp1, *tp2, *tp3;
    struct ENODE    *ep1, *ep2, *ep3;
    tp1 = orop(&ep1);       /* get condition */
    if( tp1 == NULL )
            return NULL;
    if( lastst == hook ) {
            NextToken();
            if( (tp2 = conditional(&ep2)) == NULL) {
                    error(ERR_IDEXPECT);
                    goto cexit;
                    }
            needpunc(colon);
            if( (tp3 = conditional(&ep3)) == NULL) {
                    error(ERR_IDEXPECT);
                    goto cexit;
                    }
            tp1 = forcefit(&ep2,tp2,&ep3,tp3);
            ep2 = makenode(en_void,ep2,ep3);
            ep1 = makenode(en_cond,ep1,ep2);
            }
cexit:  *node = ep1;
    return tp1;
}
 
/*
 *      asnop handles the assignment operators. currently only the
 *      simple assignment is implemented.
 */
TYP *asnop(ENODE **node)
{       struct ENODE    *ep1, *ep2, *ep3;
        TYP             *tp1, *tp2;
        int             op;
        tp1 = conditional(&ep1);
        if( tp1 == 0 )
                return 0;
        for(;;) {
                switch( lastst ) {
                        case assign:
                                op = en_assign;
ascomm:                         NextToken();
                                tp2 = asnop(&ep2);
ascomm2:                        if( tp2 == 0 || !IsLValue(ep1) )
                                        error(ERR_LVALUE);
                                else    {
                                        tp1 = forcefit(&ep1,tp1,&ep2,tp2);
                                        ep1 = makenode(op,ep1,ep2);
                                        }
                                break;
                        case asplus:
                                op = en_asadd;
ascomm3:                        tp2 = asnop(&ep2);
                                if( tp1->type == bt_pointer ) {
                                        ep3 = makeinode(en_icon,tp1->btp->size);
                                        ep2 = makenode(en_mul,ep2,ep3);
                                        }
                                goto ascomm;
                        case asminus:
                                op = en_assub;
                                goto ascomm3;
                        case astimes:
                                op = en_asmul;
                                goto ascomm;
                        case asdivide:
                                op = en_asdiv;
                                goto ascomm;
                        case asmodop:
                                op = en_asmod;
                                goto ascomm;
                        case aslshift:
                                op = en_aslsh;
                                goto ascomm;
                        case asrshift:
                                op = en_asrsh;
                                goto ascomm;
                        case asand:
                                op = en_asand;
                                goto ascomm;
                        case asor:
                                op = en_asor;
                                goto ascomm;
                        default:
                                goto asexit;
                        }
                }
asexit: *node = ep1;
        return tp1;
}
 
/*
 *      evaluate an expression where the comma operator is not legal.
 */
TYP *NonCommaExpression(ENODE **node)
{
        TYP *tp;
    tp = asnop(node);
    if( tp == NULL )
        *node = NULL;
    return tp;
}
 
/*
 *      evaluate the comma operator. comma operators are kept as
 *      void nodes.
 */
TYP *commaop(ENODE **node)
{
        TYP             *tp1;
        ENODE    *ep1, *ep2;
        tp1 = asnop(&ep1);
        if( tp1 == NULL )
                return NULL;
        if( lastst == comma ) {
                tp1 = commaop(&ep2);
                if( tp1 == NULL ) {
                        error(ERR_IDEXPECT);
                        goto coexit;
                        }
                ep1 = makenode(en_void,ep1,ep2);
                }
coexit: *node = ep1;
        return tp1;
}
 
/*
 *      evaluate an expression where all operators are legal.
 */
TYP *expression(ENODE **node)
{
        TYP *tp;
    tp = commaop(node);
    if( tp == NULL )
        *node = NULL;
    return tp;
}

Line No.	Rev	Author	Line
1	37	robfinch	`#include <stdio.h>`
2			`#include "c.h"`
3			`#include "expr.h"`
4			`#include "Statement.h"`
5			`#include "gen.h"`
6			`#include "cglbdec.h"`
7
8			`/*`
9			`* 68000 C compiler`
10			`*`
11			`* Copyright 1984, 1985, 1986 Matthew Brandt.`
12			`* all commercial rights reserved.`
13			`*`
14			`* This compiler is intended as an instructive tool for personal use. Any`
15			`* use for profit without the written consent of the author is prohibited.`
16			`*`
17			`* This compiler may be distributed freely for non-commercial use as long`
18			`* as this notice stays intact. Please forward any enhancements or questions`
19			`* to:`
20			`*`
21			`* Matthew Brandt`
22			`* Box 920337`
23			`* Norcross, Ga 30092`
24			`*/`
25			`/*******************************************************`
26			`Modified to support Raptor64 'C64' language`
27			`by Robert Finch`
28			`robfinch@opencores.org`
29			`*******************************************************/`
30
31			`TYP stdint = { bt_long, bt_long, 0, FALSE, FALSE, FALSE, 0,0,8, {0, 0}, 0, 0 };`
32			`TYP stduint = { bt_long, bt_long, 0, TRUE, FALSE, FALSE, 0,0,8, {0, 0}, 0, 0 };`
33			`TYP stdlong = { bt_long, bt_long, 0, FALSE, FALSE, FALSE, 0,0,8, {0, 0}, 0, 0 };`
34			`TYP stdulong = { bt_long, bt_long, 0, TRUE, FALSE, FALSE, 0,0,8, {0, 0}, 0, 0 };`
35			`TYP stdshort = { bt_short, bt_short, 0, FALSE, FALSE, FALSE, 0,0,4, {0, 0}, 0, 0 };`
36			`TYP stdushort = { bt_short, bt_short, 0, TRUE, FALSE, FALSE, 0,0,4, {0, 0}, 0, 0 };`
37			`TYP stdchar = {bt_char, bt_char, 0, FALSE, FALSE, FALSE, 0,0,2, {0, 0}, 0, 0 };`
38			`TYP stduchar = {bt_char, bt_char, 0, TRUE, FALSE, FALSE, 0,0,2, {0, 0}, 0, 0 };`
39			`TYP stdbyte = {bt_byte, bt_byte, 0, FALSE, FALSE, FALSE, 0,0,1, {0, 0}, 0, 0 };`
40			`TYP stdubyte = {bt_byte, bt_byte, 0, TRUE, FALSE, FALSE, 0,0,1, {0, 0}, 0, 0 };`
41			`TYP stdstring = {bt_pointer, bt_pointer, 1, FALSE, FALSE, FALSE, 0,0,4, {0, 0}, &stdchar, 0};`
42			`TYP stdfunc = {bt_func, bt_func, 1, FALSE, FALSE, FALSE, 0,0,0, {0, 0}, &stdint, 0};`
43			`extern TYP head; / shared with ParseSpecifier */`
44			`extern TYP *tail;`
45
46			`/*`
47			`* expression evaluation`
48			`*`
49			`* this set of routines builds a parse tree for an expression.`
50			`* no code is generated for the expressions during the build,`
51			`* this is the job of the codegen module. for most purposes`
52			`* expression() is the routine to call. it will allow all of`
53			`* the C operators. for the case where the comma operator is`
54			`* not valid (function parameters for instance) call NonCommaExpression().`
55			`*`
56			`* each of the routines returns a pointer to a describing type`
57			`* structure. each routine also takes one parameter which is a`
58			`* pointer to an expression node by reference (address of pointer).`
59			`* the completed expression is returned in this pointer. all`
60			`* routines return either a pointer to a valid type or NULL if`
61			`* the hierarchy of the next operator is too low or the next`
62			`* symbol is not part of an expression.`
63			`*/`
64
65			`TYP expression(); / forward ParseSpecifieraration */`
66			`TYP NonCommaExpression(); / forward ParseSpecifieraration */`
67			`TYP ParseUnaryExpression(); / forward ParseSpecifieraration */`
68
69			`/*`
70			`* build an expression node with a node type of nt and values`
71			`* v1 and v2.`
72			`*/`
73			`ENODE makenode(int nt, ENODE v1, ENODE *v2)`
74			`{`
75			`ENODE *ep;`
76			`ep = (ENODE *)xalloc(sizeof(ENODE));`
77			`ep->nodetype = nt;`
78			`ep->constflag = FALSE;`
79			`ep->etype = bt_void;`
80			`ep->esize = -1;`
81			`ep->p[0] = v1;`
82			`ep->p[1] = v2;`
83			`return ep;`
84			`}`
85
86			`ENODE makesnode(int nt, char v1)`
87			`{`
88			`ENODE *ep;`
89			`ep = (ENODE *)xalloc(sizeof(ENODE));`
90			`ep->nodetype = nt;`
91			`ep->constflag = FALSE;`
92			`ep->etype = bt_void;`
93			`ep->esize = -1;`
94			`ep->sp = v1;`
95			`return ep;`
96			`}`
97
98			`ENODE makenodei(int nt, ENODE v1, __int64 i)`
99			`{`
100			`ENODE *ep;`
101			`ep = (ENODE *)xalloc(sizeof(ENODE));`
102			`ep->nodetype = nt;`
103			`ep->constflag = FALSE;`
104			`ep->etype = bt_void;`
105			`ep->esize = -1;`
106			`ep->i = i;`
107			`ep->p[0] = v1;`
108			`ep->p[1] = NULL;`
109			`return ep;`
110			`}`
111
112			`ENODE *makeinode(int nt, __int64 v1)`
113			`{`
114			`ENODE *ep;`
115			`ep = (ENODE *)xalloc(sizeof(ENODE));`
116			`ep->nodetype = nt;`
117			`ep->constflag = TRUE;`
118			`ep->etype = bt_void;`
119			`ep->esize = -1;`
120			`ep->i = v1;`
121			`return ep;`
122			`}`
123
124			`void PromoteConstFlag(ENODE *ep)`
125			`{`
126			`ep->constflag = ep->p[0]->constflag && ep->p[1]->constflag;`
127			`}`
128
129			`/*`
130			`* build the proper dereference operation for a node using the`
131			`* type pointer tp.`
132			`*/`
133			`TYP deref(ENODE node, TYP tp)`
134			`{`
135			`switch( tp->type ) {`
136			`case bt_byte:`
137			`if (tp->isUnsigned)`
138			`node = makenode(en_ub_ref,node,NULL);`
139			`else`
140			`node = makenode(en_b_ref,node,NULL);`
141			`(*node)->esize = tp->size;`
142			`(*node)->etype = tp->type;`
143			`tp = &stdint;`
144			`break;`
145			`case bt_char:`
146			`case bt_enum:`
147			`if (tp->isUnsigned)`
148			`node = makenode(en_uc_ref,node,NULL);`
149			`else`
150			`node = makenode(en_c_ref,node,NULL);`
151			`(*node)->esize = tp->size;`
152			`(*node)->etype = tp->type;`
153			`tp = &stdchar;`
154			`break;`
155			`case bt_short:`
156			`node = makenode(en_h_ref,node,NULL);`
157			`(*node)->esize = tp->size;`
158			`(*node)->etype = tp->type;`
159			`tp = &stdint;`
160			`break;`
161			`case bt_long:`
162			`case bt_pointer:`
163			`case bt_unsigned:`
164			`(*node)->esize = tp->size;`
165			`(*node)->etype = tp->type;`
166			`node = makenode(en_w_ref,node,NULL);`
167			`break;`
168			`case bt_bitfield:`
169			`if (tp->isUnsigned){`
170			`if (tp->size==1)`
171			`node = makenode(en_ubfieldref, node, NULL);`
172			`else if (tp->size==2)`
173			`node = makenode(en_ucfieldref, node, NULL);`
174			`else if (tp->size==4)`
175			`node = makenode(en_uhfieldref, node, NULL);`
176			`else`
177			`node = makenode(en_wfieldref, node, NULL);`
178			`}`
179			`else {`
180			`if (tp->size==1)`
181			`node = makenode(en_bfieldref, node, NULL);`
182			`else if (tp->size==2)`
183			`node = makenode(en_cfieldref, node, NULL);`
184			`else if (tp->size==4)`
185			`node = makenode(en_hfieldref, node, NULL);`
186			`else`
187			`node = makenode(en_wfieldref, node, NULL);`
188			`}`
189			`(*node)->bit_width = tp->bit_width;`
190			`(*node)->bit_offset = tp->bit_offset;`
191			`/*`
192			`* maybe it should be 'unsigned'`
193			`*/`
194			`(*node)->etype = stdint.type;`
195			`(*node)->esize = tp->size;`
196			`tp = &stdint;`
197			`break;`
198			`default:`
199			`error(ERR_DEREF);`
200			`break;`
201			`}`
202			`return tp;`
203			`}`
204
205			`/*`
206			`* nameref will build an expression tree that references an`
207			`* identifier. if the identifier is not in the global or`
208			`* local symbol table then a look-ahead to the next character`
209			`* is done and if it indicates a function call the identifier`
210			`* is coerced to an external function name. non-value references`
211			`* generate an additional level of indirection.`
212			`*/`
213			`TYP nameref(ENODE *node)`
214			`{`
215			`SYM *sp;`
216			`TYP *tp;`
217	51	robfinch	`char stnm[200];`
218	37	robfinch	`sp = gsearch(lastid);`
219			`if( sp == NULL ) {`
220			`while( isspace(lastch) )`
221			`getch();`
222			`if( lastch == '(') {`
223			`++global_flag;`
224			`sp = allocSYM();`
225			`sp->tp = &stdfunc;`
226			`sp->name = litlate(lastid);`
227			`sp->storage_class = sc_external;`
228			`insert(sp,&gsyms);`
229			`--global_flag;`
230			`tp = &stdfunc;`
231			`*node = makesnode(en_nacon,sp->name);`
232			`(*node)->constflag = TRUE;`
233			`}`
234			`else {`
235			`tp = NULL;`
236			`error(ERR_UNDEFINED);`
237			`}`
238			`}`
239			`else {`
240			`if( (tp = sp->tp) == NULL ) {`
241			`error(ERR_UNDEFINED);`
242			`return NULL; /* guard against untyped entries */`
243			`}`
244			`switch( sp->storage_class ) {`
245			`case sc_static:`
246	51	robfinch	`if (sp->tp->type==bt_func \|\| sp->tp->type==bt_ifunc) {`
247			`strcpy(stnm,GetNamespace());`
248			`strcat(stnm,"_");`
249			`strcat(stnm,sp->name);`
250			`*node = makesnode(en_nacon,litlate(stnm));`
251			`(*node)->constflag = TRUE;`
252			`//*node = makesnode(en_nacon,sp->name);`
253			`//(*node)->constflag = TRUE;`
254			`}`
255			`else {`
256			`*node = makeinode(en_labcon,sp->value.i);`
257			`(*node)->constflag = TRUE;`
258			`}`
259	37	robfinch	`break;`
260			`case sc_global:`
261			`case sc_external:`
262			`*node = makesnode(en_nacon,sp->name);`
263			`(*node)->constflag = TRUE;`
264			`break;`
265			`case sc_const:`
266			`*node = makeinode(en_icon,sp->value.i);`
267			`(*node)->constflag = TRUE;`
268			`break;`
269			`default: /* auto and any errors */`
270			`if( sp->storage_class != sc_auto)`
271			`error(ERR_ILLCLASS);`
272			`*node = makeinode(en_autocon,sp->value.i);`
273			`break;`
274			`}`
275			`if( tp->val_flag == FALSE)`
276			`tp = deref(node,tp);`
277			`}`
278			`NextToken();`
279			`return tp;`
280			`}`
281
282			`/*`
283			`* ArgumentList will build a list of parameter expressions in`
284			`* a function call and return a pointer to the last expression`
285			`* parsed. since parameters are generally pushed from right`
286			`* to left we get just what we asked for...`
287			`*/`
288			`ENODE *ArgumentList()`
289			`{`
290			`struct ENODE ep1, ep2;`
291			`ep1 = 0;`
292			`while( lastst != closepa)`
293			`{`
294			`NonCommaExpression(&ep2); /* evaluate a parameter */`
295			`ep1 = makenode(en_void,ep2,ep1);`
296			`if( lastst != comma)`
297			`break;`
298			`NextToken();`
299			`}`
300			`return ep1;`
301			`}`
302
303			`/*`
304			`* return 1 if st in set of [ kw_char, kw_short, kw_long, kw_int,`
305			`* kw_float, kw_double, kw_struct, kw_union ]`
306			`*/`
307			`static int IsIntrinsicType(int st)`
308			`{`
309			`return st == kw_byte \|\| st==kw_char \|\| st == kw_short \|\| st == kw_int \|\| st==kw_void \|\|`
310			`st == kw_long \|\| st == kw_float \|\| st == kw_double \|\| st==kw_enum \|\|`
311			`st == kw_struct \|\| st == kw_union \|\| st== kw_unsigned \|\| st==kw_signed;`
312			`}`
313
314			`int IsBeginningOfTypecast(int st)`
315			`{`
316			`SYM *sp;`
317			`if (st==id) {`
318			`sp = search(lastid,&gsyms[0]);`
319			`if (sp)`
320			`return sp->storage_class==sc_typedef;`
321			`return FALSE;`
322			`}`
323			`else`
324			`return IsIntrinsicType(st);`
325			`}`
326
327			`/*`
328			`* primary will parse a primary expression and set the node pointer`
329			`* returning the type of the expression parsed. primary expressions`
330			`* are any of:`
331			`* id`
332			`* constant`
333			`* string`
334			`* ( expression )`
335			`* primary[ expression ]`
336			`* primary.id`
337			`* primary->id`
338			`* primary( parameter list )`
339			`*/`
340			`TYP ParsePrimaryExpression(ENODE *node)`
341			`{`
342	51	robfinch	`ENODE pnode, qnode, rnode, snode, rnode1, pnode1, qnode1, qnode2;`
343			`__int64 i ;`
344			`int sza[10];`
345			`int brcount;`
346	37	robfinch	`SYM *sp;`
347			`TYP *tptr;`
348	51	robfinch	`brcount = 0;`
349			`qnode1 = NULL;`
350			`qnode2 = NULL;`
351	37	robfinch	`switch( lastst ) {`
352
353			`case id:`
354			`tptr = nameref(&pnode);`
355			`break;`
356			`case iconst:`
357			`tptr = &stdint;`
358			`pnode = makeinode(en_icon,ival);`
359			`pnode->constflag = TRUE;`
360			`NextToken();`
361			`break;`
362			`case sconst:`
363			`tptr = &stdstring;`
364	51	robfinch	`pnode = makenodei(en_labcon,NULL,stringlit(laststr));`
365	37	robfinch	`pnode->constflag = TRUE;`
366			`NextToken();`
367			`break;`
368
369			`case openpa:`
370			`NextToken();`
371			`if( !IsBeginningOfTypecast(lastst) ) {`
372			`tptr = expression(&pnode);`
373			`needpunc(closepa);`
374			`}`
375			`else { /* cast operator */`
376			`ParseSpecifier(0); /* do cast ParseSpecifieraration */`
377			`ParseDeclarationPrefix(FALSE);`
378			`tptr = head;`
379			`needpunc(closepa);`
380			`if( ParseUnaryExpression(&pnode) == NULL ) {`
381			`error(ERR_IDEXPECT);`
382			`tptr = NULL;`
383			`}`
384			`}`
385			`break;`
386
387			`default:`
388			`return NULL;`
389			`}`
390			`for(;;) {`
391			`switch( lastst ) {`
392			`case openbr: /* build a subscript reference */`
393	51	robfinch	`brcount++;`
394	37	robfinch	`if (tptr==NULL) {`
395			`error(ERR_UNDEFINED);`
396			`goto fini;`
397			`}`
398			`if( tptr->type != bt_pointer )`
399			`error(ERR_NOPOINTER);`
400			`else`
401			`tptr = tptr->btp;`
402			`NextToken();`
403	51	robfinch	`if (tptr->val_flag && (tptr->size==1 \|\| tptr->size==2 \|\| tptr->size==4 \|\| tptr->size==8)) {`
404			`expression(&rnode);`
405			`pnode = makenode(en_add,rnode,pnode);`
406			`pnode->constflag = rnode->constflag && pnode->p[1]->constflag;`
407			`pnode->scale = tptr->size;`
408			`}`
409			`else {`
410			`sza[brcount-1] = tptr->size;`
411			`qnode = makeinode(en_icon,tptr->size);`
412			`// swap sizes for array indexing`
413			`if (brcount==3) {`
414			`qnode->i = sza[0];`
415			`qnode2->i = sza[1];`
416			`qnode1->i = sza[2];`
417			`}`
418			`else if (brcount==2) {`
419			`qnode->i = sza[0];`
420			`qnode1->i = sza[1];`
421			`}`
422			`if (qnode1==NULL)`
423			`qnode1 = qnode;`
424			`else`
425			`qnode2 = qnode;`
426			`qnode->constflag = TRUE;`
427			`expression(&rnode);`
428			`needpunc(closebr);`
429			`/*`
430	37	robfinch	`* we could check the type of the expression here...`
431			`*/`
432	51	robfinch	`qnode = makenode(en_mulu,qnode,rnode);`
433			`qnode->constflag = rnode->constflag && qnode->p[0]->constflag;`
434			`pnode = makenode(en_add,qnode,pnode);`
435			`pnode->constflag = qnode->constflag && pnode->p[1]->constflag;`
436			`pnode->scale = 1;`
437			`//if( tptr->val_flag == 0 )`
438			`// tptr = deref(&pnode,tptr);`
439			`}`
440	37	robfinch	`////snode = makenode(en_mul,qnode,rnode);`
441			`////snode->constflag = rnode->constflag && snode->p[0]->constflag;`
442			`////pnode = makenode(en_add,snode,pnode);`
443			`////pnode->constflag = snode->constflag && pnode->p[1]->constflag;`
444			`if( tptr->val_flag == FALSE )`
445			`tptr = deref(&pnode,tptr);`
446	51	robfinch	`// needpunc(closebr);`
447	37	robfinch	`break;`
448
449			`case pointsto:`
450			`if (tptr==NULL) {`
451			`error(ERR_UNDEFINED);`
452			`goto fini;`
453			`}`
454			`if( tptr->type != bt_pointer )`
455			`error(ERR_NOPOINTER);`
456			`else`
457			`tptr = tptr->btp;`
458			`if( tptr->val_flag == FALSE )`
459			`pnode = makenode(en_w_ref,pnode,NULL);`
460			`/*`
461			`* fall through to dot operation`
462			`*/`
463			`case dot:`
464			`NextToken(); /* past -> or . */`
465			`if( lastst != id )`
466			`error(ERR_IDEXPECT);`
467			`else {`
468			`sp = search(lastid,&tptr->lst);`
469			`if( sp == NULL )`
470			`error(ERR_NOMEMBER);`
471			`else {`
472			`tptr = sp->tp;`
473			`qnode = makeinode(en_icon,sp->value.i);`
474			`qnode->constflag = TRUE;`
475			`pnode = makenode(en_add,pnode,qnode);`
476			`pnode->constflag = pnode->p[0]->constflag;`
477			`if( tptr->val_flag == FALSE )`
478			`tptr = deref(&pnode,tptr);`
479			`}`
480			`NextToken(); /* past id */`
481			`}`
482			`break;`
483
484			`case openpa: /* function reference */`
485			`NextToken();`
486			`if( tptr->type != bt_func && tptr->type != bt_ifunc )`
487			`error(ERR_NOFUNC);`
488			`else`
489			`tptr = tptr->btp;`
490			`currentFn->IsLeaf = FALSE;`
491			`pnode = makenode(en_fcall,pnode,ArgumentList());`
492			`needpunc(closepa);`
493			`break;`
494
495			`default:`
496			`goto fini;`
497			`}`
498			`}`
499			`fini: *node = pnode;`
500			`return tptr;`

Browse

Tools

Subversion Repositories raptor64

[/] [raptor64/] [trunk/] [software/] [c64/] [source/] [ParseExpressions.c] - Blame information for rev 51