#include        <stdio.h>
#include        "c.h"
#include        "expr.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
 */

/*
 *      the statement module handles all of the possible c statements
 *      and builds a parse tree of the statements.
 *
 *      each routine returns a pointer to a statement parse node which
 *      reflects the statement just parsed.
 */

struct snode    *statement();   /* forward declaration */

struct snode    *whilestmt()
/*
 *      whilestmt parses the c while statement.
 */
{       struct snode    *snp;
        snp = xalloc(sizeof(struct snode));
        snp->stype = st_while;
        getsym();
        if( lastst != openpa )
                error(ERR_EXPREXPECT);
        else    {
                getsym();
                if( expression(&(snp->exp)) == 0 )
                        error(ERR_EXPREXPECT);
                needpunc( closepa );
                snp->s1 = statement();
                }
        return snp;
}

struct snode    *dostmt()
/*
 *      dostmt parses the c do-while construct.
 */
{       struct snode    *snp;
        snp = xalloc(sizeof(struct snode));
        snp->stype = st_do;
        getsym();
        snp->s1 = statement();
        if( lastst != kw_while )
                error(ERR_WHILEXPECT);
        else    {
                getsym();
                if( lastst != openpa )
                        error(ERR_EXPREXPECT);
                else    {
                        getsym();
                        if( expression(&(snp->exp)) == 0 )
                                error(ERR_EXPREXPECT);
                        needpunc(closepa);
                        }
                if( lastst != end )
                        needpunc( semicolon );
                }
        return snp;
}

struct snode    *forstmt()
{       struct snode    *snp;
        snp = xalloc(sizeof(struct snode));
        getsym();
        needpunc(openpa);
        if( expression(&(snp->label)) == 0 )
                snp->label = 0;
        needpunc(semicolon);
        snp->stype = st_for;
        if( expression(&(snp->exp)) == 0 )
                snp->exp = 0;
        needpunc(semicolon);
        if( expression(&(snp->s2)) == 0 )
                snp->s2 = 0;
        needpunc(closepa);
        snp->s1 = statement();
        return snp;
}

struct snode    *ifstmt()
/*
 *      ifstmt parses the c if statement and an else clause if
 *      one is present.
 */
{       struct snode    *snp;
        snp = xalloc(sizeof(struct snode));
        snp->stype = st_if;
        getsym();
        if( lastst != openpa )
                error(ERR_EXPREXPECT);
        else    {
                getsym();
                if( expression(&(snp->exp)) == 0 )
                        error(ERR_EXPREXPECT);
                needpunc( closepa );
                snp->s1 = statement();
                if( lastst == kw_else ) {
                        getsym();
                        snp->s2 = statement();
                        }
                else
                        snp->s2 = 0;
                }
        return snp;
}

struct snode    *casestmt()
/*
 *      cases are returned as seperate statements. for normal
 *      cases label is the case value and s2 is zero. for the
 *      default case s2 is nonzero.
 */
{       struct snode    *snp;
        struct snode    *head, *tail;
        snp = xalloc(sizeof(struct snode));
        if( lastst == kw_case ) {
                getsym();
                snp->s2 = 0;
                snp->stype = st_case;
                snp->label = intexpr();
                }
        else if( lastst == kw_default) {
                getsym();
                snp->s2 = 1;
                }
        else    {
                error(ERR_NOCASE);
                return 0;
                }
        needpunc(colon);
        head = 0;
        while( lastst != end &&
                lastst != kw_case &&
                lastst != kw_default ) {
                if( head == 0 )
                        head = tail = statement();
                else    {
                        tail->next = statement();
                        if( tail->next != 0 )
                                tail = tail->next;
                        }
                tail->next = 0;
                }
        snp->s1 = head;
        return snp;
}

int     checkcases(head)
/*
 *      checkcases will check to see if any duplicate cases
 *      exist in the case list pointed to by head.
 */
struct snode    *head;
{
	struct snode	*top, *cur;
	cur = top = head;
	while( top != 0 )
	{
		cur = top->next;
		while( cur != 0 )
		{
			if( (!(cur->s1 || cur->s2) && cur->label == top->label)
				|| (cur->s2 && top->s2) )
			{
				printf(" duplicate case label %d\n",cur->label);
				return 1;
			}
			cur = cur->next;
		}
		top = top->next;
	}
	return 0;
}

struct snode    *switchstmt()
{       struct snode    *snp;
        struct snode    *head, *tail;
        snp = xalloc(sizeof(struct snode));
        snp->stype = st_switch;
        getsym();
        needpunc(openpa);
        if( expression(&(snp->exp)) == 0 )
                error(ERR_EXPREXPECT);
        needpunc(closepa);
        needpunc(begin);
        head = 0;
        while( lastst != end ) {
                if( head == 0 )
                        head = tail = casestmt();
                else    {
                        tail->next = casestmt();
                        if( tail->next != 0 )
                                tail = tail->next;
                        }
                tail->next = 0;
                }
        snp->s1 = head;
        getsym();
        if( checkcases(head) )
                error(ERR_DUPCASE);
        return snp;
}

struct snode    *retstmt()
{       struct snode    *snp;
        snp = xalloc(sizeof(struct snode));
        snp->stype = st_return;
        getsym();
        expression(&(snp->exp));
        if( lastst != end )
                needpunc( semicolon );
        return snp;
}

struct snode    *breakstmt()
{       struct snode    *snp;
        snp = xalloc(sizeof(struct snode));
        snp->stype = st_break;
        getsym();
        if( lastst != end )
                needpunc( semicolon );
        return snp;
}

struct snode    *contstmt()
{       struct snode    *snp;
        snp = xalloc(sizeof(struct snode));
        snp->stype = st_continue;
        getsym();
        if( lastst != end )
                needpunc( semicolon );
        return snp;
}

struct snode    *exprstmt()
/*
 *      exprstmt is called whenever a statement does not begin
 *      with a keyword. the statement should be an expression.
 */
{       struct snode    *snp;
        snp = xalloc(sizeof(struct snode));
        snp->stype = st_expr;
        if( expression(&(snp->exp)) == 0 ) {
                error(ERR_EXPREXPECT);
                getsym();
                }
        if( lastst != end )
                needpunc( semicolon );
        return snp;
}

struct snode    *compound()
/*
 *      compound processes a block of statements and forms a linked
 *      list of the statements within the block.
 *
 *      compound expects the input pointer to already be past the
 *      begin symbol of the block.
 */
{       struct snode    *head, *tail;
        head = 0;
        while( lastst != end ) {
                if( head == 0 )
                        head = tail = statement();
                else    {
                        tail->next = statement();
                        if( tail->next != 0 )
                                tail = tail->next;
                        }
                }
        getsym();
        return head;
}

struct snode    *labelstmt()
/*
 *      labelstmt processes a label that appears before a
 *      statement as a seperate statement.
 */
{       struct snode    *snp;
        SYM             *sp;
        snp = xalloc(sizeof(struct snode));
        snp->stype = st_label;
        if( (sp = search(lastid,lsyms.head)) == 0 ) {
                sp = xalloc(sizeof(SYM));
                sp->name = litlate(lastid);
                sp->storage_class = sc_label;
                sp->tp = 0;
                sp->value.i = nextlabel++;
                insert(sp,&lsyms);
                }
        else    {
                if( sp->storage_class != sc_ulabel )
                        error(ERR_LABEL);
                else
                        sp->storage_class = sc_label;
                }
        getsym();       /* get past id */
        needpunc(colon);
        if( sp->storage_class == sc_label ) {
                snp->label = sp->value.i;
                snp->next = 0;
                return snp;
                }
        return 0;
}

struct snode    *gotostmt()
/*
 *      gotostmt processes the goto statement and puts undefined
 *      labels into the symbol table.
 */
{       struct snode    *snp;
        SYM             *sp;
        getsym();
        if( lastst != id ) {
                error(ERR_IDEXPECT);
                return 0;
                }
        snp = xalloc(sizeof(struct snode));
        if( (sp = search(lastid,lsyms.head)) == 0 ) {
                sp = xalloc(sizeof(SYM));
                sp->name = litlate(lastid);
                sp->value.i = nextlabel++;
                sp->storage_class = sc_ulabel;
                sp->tp = 0;
                insert(sp,&lsyms);
                }
        getsym();       /* get past label name */
        if( lastst != end )
                needpunc( semicolon );
        if( sp->storage_class != sc_label && sp->storage_class != sc_ulabel)
                error( ERR_LABEL );
        else    {
                snp->stype = st_goto;
                snp->label = sp->value.i;
                snp->next = 0;
                return snp;
                }
        return 0;
}

struct snode    *statement()
/*
 *      statement figures out which of the statement processors
 *      should be called and transfers control to the proper
 *      routine.
 */
{       struct snode    *snp;
        switch( lastst ) {
                case semicolon:
                        getsym();
                        snp = 0;
                        break;
                case begin:
                        getsym();
                        snp = compound();
                        return snp;
                case kw_if:
                        snp = ifstmt();
                        break;
                case kw_while:
                        snp = whilestmt();
                        break;
                case kw_for:
                        snp = forstmt();
                        break;
                case kw_return:
                        snp = retstmt();
                        break;
                case kw_break:
                        snp = breakstmt();
                        break;
                case kw_goto:
                        snp = gotostmt();
                        break;
                case kw_continue:
                        snp = contstmt();
                        break;
                case kw_do:
                        snp = dostmt();
                        break;
                case kw_switch:
                        snp = switchstmt();
                        break;
                case id:
                        while( isspace(lastch) )
                                getch();
                        if( lastch == ':' )
                                return labelstmt();
                        /* else fall through to process expression */
                default:
                        snp = exprstmt();
                        break;
                }
        if( snp != 0 )
                snp->next = 0;
        return snp;
}