emit.c

来自「<B>Digital的Unix操作系统VAX 4.2源码</B>」· C语言 代码 · 共 814 行 · 第 1/2 页

	}
    printf(")\n");

    for (st=tn->firstsym; st != NULL; st = st->st_link)
	{
	emittype(st,0);
	/*
	 * Skip over entries of duplicate vars w/ same type.
	 */
	for (; st->st_dupvar != NULL; )
	    st = st->st_dupvar;
	if (st == tn->lastsym)
	    break;
	}
}


/*
 * Emit while stmt.
 */

emitwhile(tn)
    struct treenode *tn;
{
    indent(lexlev);
    printf("while (%s)\n", tn->expression);
    lexlev++;
    emitcode(tn->firstc);
    lexlev--;
    emitcode(tn->next);
}


/*
 * Emit repeat stmt.
 */

emitrepeat(tn)
    struct treenode *tn;
{
    indent(lexlev);
    printf("do {\n");
    lexlev++;
    emitcode(tn->firstc);
    lexlev--;
    indent(lexlev);
    printf("} while (%s);\n", tn->expression);
    emitcode(tn->next);
}


/* 
 * Emit constants.
 */

emitconst(st)
    struct stentry *st;
{
    printf("#define %s ",st->st_name);
    switch (st->st_tipe)
	{
	case INTTY:		/* also handles Pascal T/F as 1/0 */
	default:
	    printf("%d", st->st_cval);
	    break;
	case REALTY:
	    printf("%f", st->st_fcval);
	    break;
	case CHARTY:
	    printf("'%c'", st->st_cval);
	    break;
	case STRINGTY:
	    printf("\"%s\"", st->st_string);
	    break;
	case OCTALTY:
	    printf("0%s", st->st_uptr);
	    break;
	case HEXTY:
	    printf("0x%s", st->st_uptr);
	    break;
	case USERTYPE:
	    printf("%s", st->st_uptr->st_name);
	    break;
	}
    if (st->st_cmt != NULL)
	prstcmt(st->st_cmt);
    printf("\n");
}


/* 
 * Emit data types.
 * called by emitbegin, emitparam, emitproc
 */

emittype(st, nosemi)
    struct stentry *st;
    char nosemi;		/* true if no ';' wanted (function type) */
{
    register int i;
    register struct stentry *stptr;
    register struct pairs *pr;

    indent(lexlev);
    if (st->st_class == TYPEC && st->st_dstruct != RECORDS)
	printf("typedef ");
    switch (st->st_dstruct) {
	case NOSTRUCT:		/* symple type */
	case SUBRANGES: /* No subranges in C so make it just a scaler type */
	case SETS: 	/* No sets in C so make it just a scaler type */
	    prtipe(st);
	    if (st->st_funcpar && st->st_class == VARC)
		printf("(*");
	    printf("%s%s%s", (st->st_byref) ? "*" : "",
			(st->st_funcvar) ? "v___" : "", st->st_name);
	    if (st->st_funcpar && st->st_class == VARC)
		printf(")()");
	    for (stptr = st->st_dupvar; stptr != NULL; stptr = stptr->st_dupvar)
		printf(", %s%s", (st->st_byref) ? "*" : "", stptr->st_name);
	    if (st->st_value != NULL)
		printf(" = %s", st->st_value);
	    if (nosemi == 0)
		printf(";");
	    if (st->st_cmt != NULL)
		prstcmt(st->st_cmt);
	    printf("\n");
	    break;
	case ARRS:
	    prtipe(st);
	    printf("%s", st->st_name);
	    pr = st->st_bounds;
	    for (i=0; i < st->st_numdims; i++)
		{
		if (pr->pr_upper == -1)
		    printf("[%s+1]", pr->pr_uuser->st_name);
		else
		    printf("[%d]", pr->pr_upper);
		pr = pr->pr_next;
		}
	    for (stptr = st->st_dupvar; stptr != NULL; stptr = stptr->st_dupvar)
		{
		printf(", %s", stptr->st_name);
		pr = st->st_bounds;
		for (i=0; i < st->st_numdims; i++)
		    {
		    if (pr->pr_upper == -1)
			printf("[%s+1]", pr->pr_uuser->st_name);
		   else
		       printf("[%d]", pr->pr_upper);
		    pr = pr->pr_next;
		    }
		}
	    if (st->st_value != NULL)
		printf(" = %s", st->st_value);
	    if (nosemi == 0)
		printf(";");
	    if (st->st_cmt != NULL)
		prstcmt(st->st_cmt);
	    printf("\n");
	    break;
	case UDEFS:
	    if (st->st_tipe == ENUMTY)
		{
		if (st->st_class == TYPEC)
		    printf("enum %s {", st->st_name);
		else
		    printf("enum dummy {");
		/*
		 * Follow uptr to 1st enum const!  This is necessary for
		 * constructs like: v1, v2: (red,blue,green);
		 * v2's st_link does NOT point to red, but rather to the
		 * next variable.
		 */
		stptr = st;
		for (i=0; i < st->st_numdims; i++)
		    {
		    if (i == 0)
			stptr = stptr->st_uptr;
		    else
			stptr = stptr->st_link;
		    printf("%s", stptr->st_name);
		    if (i < st->st_numdims-1)
			printf(", ");
		    }
		if (st->st_class == TYPEC)
		    {
		    printf("}");
		    if (st->st_value != NULL)
			printf(" = %s", st->st_value);
		    printf(";");
		    if (st->st_cmt != NULL)
			prstcmt(st->st_cmt);
		    printf("\n");
		    }
		else
		    {
		    printf("} ");
		    printf("%s", st->st_name);
		    for (stptr = st->st_dupvar; stptr != NULL; stptr = stptr->st_dupvar)
			printf(", %s", stptr->st_name);
		    if (st->st_value != NULL)
			printf(" = %s", st->st_value);
		    printf(";");
		    if (st->st_cmt != NULL)
			prstcmt(st->st_cmt);
		    printf("\n");
		    }
		}   /* end ENUMTY */
	    else
		{
		if (st->st_tipe == USERTYPE)
		    {
		    prtipe(st);
		    if (st->st_funcpar && st->st_class == VARC)
			printf("(*");
		    printf("%s%s%s", (st->st_byref) ? "*" : "",
				(st->st_funcvar) ? "v___" : "", st->st_name);
		    if (st->st_funcpar && st->st_class == VARC)
			printf(")()");
		    for (stptr = st->st_dupvar; stptr != NULL; stptr = stptr->st_dupvar)
			printf(", %s%s", (st->st_byref) ? "*" : "", stptr->st_name);
		    if (st->st_value != NULL)
			printf(" = %s", st->st_value);
		    if (nosemi == 0)
			printf(";");
		    if (st->st_cmt != NULL)
			prstcmt(st->st_cmt);
		    printf("\n");
		    }
		}
	    break;
	case RECORDS:
	    if (st->st_tipe == UNIONTY)
		printf("union {\n");
	    else if (st->st_class == TYPEC)
		printf("struct %s {\n", st->st_name);
	    else
		printf("struct {\n");
	    lexlev++;
	    stptr = st;
	    for (stptr = stptr->st_next; stptr != NULL ; )
		{
		emittype(stptr,0);
		/*
		 * In case of dupvars as field list items, its only
		 * from the end of the dupvar chain that you can:
		 * 1) Follow the "st_link" pointer to go on after
		 *    a nested record.
		 * 2) Follow the "st_next" pointer to go on after
		 *    anything other than a nested record type.
		 */
		if (stptr->st_dstruct == RECORDS)
		    {
		    for (; stptr->st_dupvar != NULL; )
			stptr = stptr->st_dupvar;
		    stptr = stptr->st_link;
		    }
		else
		    {
		    for (; stptr->st_dupvar != NULL; )
			stptr = stptr->st_dupvar;
		    stptr = stptr->st_next;
		    }
		}

	    indent(lexlev);
	    if (st->st_class == TYPEC)
		{
		printf("}");
		if (st->st_value != NULL)
		    printf(" = %s", st->st_value);
		printf(";");
		if (st->st_cmt != NULL)
		    prstcmt(st->st_cmt);
		printf("\n");
		}
	    else
		{
		printf("} %s", st->st_name);
		for (stptr = st->st_dupvar; stptr != NULL; stptr = stptr->st_dupvar)
		    printf(", %s", stptr->st_name);
		if (st->st_value != NULL)
		    printf(" = %s", st->st_value);
		if (nosemi == 0)
		    printf(";");
		if (st->st_cmt != NULL)
		    prstcmt(st->st_cmt);
		printf("\n");
		}
	    lexlev--;
	    /*
	     * Print out any union field "defines"
	     */
	    for (stptr = st->st_link; stptr != NULL; stptr = stptr->st_link)
		{
		if (stptr->st_class == DEFINEC)
		    printf("#define %s %s\n", stptr->st_name, stptr->st_cmt->cmt);
		else
		    break;
		}
	    break;
	case FILESTR:
	    printf("FILE *%s", st->st_name);
	    if (st->st_value != NULL)
		printf(" = %s", st->st_value);
	    printf(";");
	    if (st->st_cmt != NULL)
		prstcmt(st->st_cmt);
	    printf("\n");
	    break;
	case PTRS:
	    if (st->st_tipe == USERTYPE)
		{
		if (st->st_uptr != NULL)
		    if (st->st_uptr->st_dstruct == RECORDS)
			printf("struct ");
		printf("%s ", st->st_uptr->st_name);
		}
	    else
		prtipe(st);
	    printf("*%s", st->st_name);
	    for (stptr = st->st_dupvar; stptr != NULL; stptr = stptr->st_dupvar)
		printf(", *%s", stptr->st_name);
	    if (st->st_value != NULL)
		printf(" = %s", st->st_value);
	    if (nosemi == 0)
		printf(";");
	    if (st->st_cmt != NULL)
		prstcmt(st->st_cmt);
	    printf("\n");
	    break;
	}   /* switch (st->st_dstruct) */
}

/*
 * Print stentry comment
 */

prstcmt(chead)
    struct cmtinfo *chead;
{
    register struct cmtinfo *cptr;

    printf("\t/*");
    for (cptr = chead; cptr != NULL; cptr = cptr->next)
	{
	if (cptr != chead)
	    printf("\n");
	printf("%s", cptr->cmt);
	}
    printf("*/");
}


/*
 * Print base type
 */

prtipe(st)
    struct stentry *st;
{
    switch (st->st_tipe) {
	case BOOLTY:
	case CHARTY:
	    printf("char ");
	    break;
	case INTTY:
	    printf("int ");
	    break;
	case USERTYPE:
	    if (st->st_uptr->st_tipe == ENUMTY)
		printf("enum ");
	    else if (st->st_uptr->st_dstruct == RECORDS)
		printf("struct ");
	    printf("%s ",st->st_uptr->st_name);
	    break;
	case REALTY:
	    printf("float ");
	    break;
	case UNSIGNEDTY:
	    printf("unsigned ");
	    break;
	case DOUBLETY:
	    printf("double ");
	    break;
	default:
	    fprintf(stderr,"Internal error, routine prtipe, default case.\n");
	    fprintf(stderr,"    type = %d\n", st->st_tipe);
	    exit();
	    break;
	}   /* switch (st->st_tipe) */
}


emitproc(tn, func)
    struct treenode *tn;
    char func;
{
    if (func)
	emittype(tn->ftype,1);
    printf("%s ", tn->stdecl->st_name);
    lexlev++;
    emitcode(tn->firstc);
    lexlev--;
    emitcode(tn->next);
}