case MEMBER_SELECTOR_OP:
            printf(".");
            break;
        case ARRAY_INDEX_OP:
            printf("[");
            break;
        case FUN_CALL_OP:
        case FUN_BUILTIN_OP:
            printf("(");
            break;
        case FUN_ARG_OP:
        case EXPR_LIST_OP:
            if (fexpr->bin.right)
                printf(", ");
            break;
        case MUL_OP:
        case MUL_SV_OP:
        case MUL_VS_OP:
        case MUL_V_OP:
            printf("*");
            break;
        case DIV_OP:
        case DIV_SV_OP:
        case DIV_VS_OP:
        case DIV_V_OP:
            printf("/");
            break;
        case MOD_OP:
        case MOD_SV_OP:
        case MOD_VS_OP:
        case MOD_V_OP:
            printf("%");
            break;
        case ADD_OP:
        case ADD_SV_OP:
        case ADD_VS_OP:
        case ADD_V_OP:
            printf(" + ");
            break;
        case SUB_OP:
        case SUB_SV_OP:
        case SUB_VS_OP:
        case SUB_V_OP:
            printf(" - ");
            break;
        case SHL_OP:
        case SHL_V_OP:
            printf(" << ");
            break;
        case SHR_OP:
        case SHR_V_OP:
            printf(" >> ");
            break;
        case LT_OP:
        case LT_SV_OP:
        case LT_VS_OP:
        case LT_V_OP:
            printf(" < ");
            break;
        case GT_OP:
        case GT_SV_OP:
        case GT_VS_OP:
        case GT_V_OP:
            printf(" > ");
            break;
        case LE_OP:
        case LE_SV_OP:
        case LE_VS_OP:
        case LE_V_OP:
            printf(" <= ");
            break;
        case GE_OP:
        case GE_SV_OP:
        case GE_VS_OP:
        case GE_V_OP:
            printf(" >= ");
            break;
        case EQ_OP:
        case EQ_SV_OP:
        case EQ_VS_OP:
        case EQ_V_OP:
            printf(" == ");
            break;
        case NE_OP:
        case NE_SV_OP:
        case NE_VS_OP:
        case NE_V_OP:
            printf(" != ");
            break;
        case AND_OP:
        case AND_SV_OP:
        case AND_VS_OP:
        case AND_V_OP:
            printf(" & ");
            break;
        case XOR_OP:
        case XOR_SV_OP:
        case XOR_VS_OP:
        case XOR_V_OP:
            printf(" ^ ");
            break;
        case OR_OP:
        case OR_SV_OP:
        case OR_VS_OP:
        case OR_V_OP:
            printf(" | ");
            break;
        case BAND_OP:
        case BAND_SV_OP:
        case BAND_VS_OP:
        case BAND_V_OP:
            printf(" && ");
            break;
        case BOR_OP:
        case BOR_SV_OP:
        case BOR_VS_OP:
        case BOR_V_OP:
            printf(" || ");
            break;
        case ASSIGN_OP:
        case ASSIGN_V_OP:
        case ASSIGN_GEN_OP:
            printf(" = ");
            break;
        case ASSIGNMINUS_OP:
            printf(" -= ");
            break;
        case ASSIGNMOD_OP:
            printf(" %= ");
            break;
        case ASSIGNPLUS_OP:
            printf(" += ");
            break;
        case ASSIGNSLASH_OP:
            printf(" /= ");
            break;
        case ASSIGNSTAR_OP:
            printf(" *= ");
            break;
        case ASSIGN_MASKED_KV_OP:
            printf("@@");
            mask = SUBOP_GET_MASK(fexpr->bin.subop);
            for (ii = 3; ii >= 0; ii--) {
                if (mask & 1)
                    printf("%c", "wzyx"[ii]);
                mask >>= 1;
            }
            printf(" = ");
            break;
        case COMMA_OP:
            printf(" , ");
            break;
        default:
            printf("<!BINOP=%d>", fexpr->bin.op);
            break;
        }
        if (fexpr->bin.right)
            lPrintExpr(fexpr->bin.right);
        switch (fexpr->bin.op) {
        case ARRAY_INDEX_OP:
            printf("]");
            break;
        case FUN_CALL_OP:
        case FUN_BUILTIN_OP:
            printf(")");
            break;
        default:
            break;
        }
        break;
    case TRINARY_N:
        lPrintExpr(fexpr->tri.arg1);
        switch (fexpr->tri.op) {
        case COND_OP:
        case COND_V_OP:
        case COND_SV_OP:
        case COND_GEN_OP:
            printf(" ? ");
            if (fexpr->tri.arg2)
                lPrintExpr(fexpr->tri.arg2);
            printf(" : ");
            if (fexpr->tri.arg3)
                lPrintExpr(fexpr->tri.arg3);
            break;
        case ASSIGN_COND_OP:
        case ASSIGN_COND_V_OP:
        case ASSIGN_COND_SV_OP:
        case ASSIGN_COND_GEN_OP:
            printf("@@(");
            if (fexpr->tri.arg2)
                lPrintExpr(fexpr->tri.arg2);
            printf(") = ");
            if (fexpr->tri.arg3)
                lPrintExpr(fexpr->tri.arg3);
            break;
        default:
            printf("<!TRIOP=%d>", fexpr->tri.op);
            break;
        }
        break;
    default:
        printf("<!NODEKIND=%d>", fexpr->common.kind);
        break;
    }
} // lPrintExpr

/*
 * PrintExpression()
 *
 */

void PrintExpression(expr *fexpr)
{
    printf("expr: ");
    lPrintExpr(fexpr);
    printf("\n");
} // PrintExpression

static void lPrintStmt(stmt *fstmt, int level, const char *fcomment);

/*
 * lPrintStmtList()
 *
 */

static void lPrintStmtList(stmt *fstmt, int level, const char *fcomment)
{
    while (fstmt) {
        lPrintStmt(fstmt, level, fcomment);
        fstmt = fstmt->commonst.next;
    }
}

/*
 * lPrintStmt()
 *
 */

static void lPrintStmt(stmt *fstmt, int level, const char *fcomment)
{
    stmt *lstmt;

    switch (fstmt->exprst.kind) {
    case EXPR_STMT:
        lIndent(level);
        if (fstmt->exprst.exp) {
            lPrintExpr(fstmt->exprst.exp);
        } else {
            printf("/* empty statement */");
        }
        printf(";\n");
        break;
    case IF_STMT:
        lIndent(level);
        printf("if (");
        lPrintExpr(fstmt->ifst.cond);
        printf(")\n");
        lPrintStmtList(fstmt->ifst.thenstmt, level + 1, NULL);
        if (fstmt->ifst.elsestmt) {
            lIndent(level);
            printf("else\n");
            lPrintStmtList(fstmt->ifst.elsestmt, level + 1, NULL);
        }
        break;
    case WHILE_STMT:
        lIndent(level);
        printf("while (");
        lPrintExpr(fstmt->whilest.cond);
        printf(")\n");
        lPrintStmtList(fstmt->whilest.body, level + 1, NULL);
        break;
    case DO_STMT:
        lIndent(level);
        printf("do\n");
        lPrintStmtList(fstmt->whilest.body, level + 1, NULL);
        lIndent(level);
        printf("while (");
        lPrintExpr(fstmt->whilest.cond);
        printf(");\n");
        break;
    case FOR_STMT:
        lIndent(level);
        printf("for (");
        lstmt = fstmt->forst.init;
        if (lstmt) {
            while (lstmt) {
                if (lstmt->exprst.kind == EXPR_STMT) {
                    lPrintExpr(lstmt->exprst.exp);
                } else {
                    printf("*** BAD STMT KIND ***");
                }
                if (lstmt->exprst.next)
                    printf(", ");
                lstmt = lstmt->exprst.next;
            }
        }
        printf(";");
        if (fstmt->forst.cond) {
            printf(" ");
            lPrintExpr(fstmt->forst.cond);
        }
        printf(";");
        lstmt = fstmt->forst.step;
        if (lstmt) {
            printf(" ");
            while (lstmt) {
                if (lstmt->exprst.kind == EXPR_STMT) {
                    lPrintExpr(lstmt->exprst.exp);
                } else {
                    printf("*** BAD STMT KIND ***");
                }
                if (lstmt->exprst.next)
                    printf(", ");
                lstmt = lstmt->exprst.next;
            }
        }
        printf(")\n");
        lPrintStmtList(fstmt->forst.body, level + 1, NULL);
        break;
    case BLOCK_STMT:
        if (level > 1)
            lIndent(level - 1);
        printf("{\n");
        lPrintStmtList(fstmt->blockst.body, level, NULL);
        if (level > 1)
            lIndent(level - 1);
        if (fcomment) {
            printf("} // %s\n", fcomment);
        } else {
            printf("}\n");
        }
        break;
    case RETURN_STMT:
        lIndent(level);
        printf("return");
        if (fstmt->returnst.exp) {
            printf(" ");
            lPrintExpr(fstmt->returnst.exp);
        }
        printf(";\n");
        break;
    case DISCARD_STMT:
        lIndent(level);
        printf("discard");
        if (fstmt->discardst.cond) {
            printf(" ");
            lPrintExpr(fstmt->discardst.cond);
        }
        printf(";\n");
        break;
    case COMMENT_STMT:
        lIndent(level);
        printf("// %s\n", GetAtomString(atable, fstmt->commentst.str));
        break;
    default:
        lIndent(level);
        printf("<!BadStmt-0x%2x>\n", fstmt->exprst.kind);
    }
} // lPrintStmt

/*
 * PrintStmt()
 *
 */

void PrintStmt(stmt *fstmt)
{
    lPrintStmt(fstmt, 0, NULL);
} // PrintStmt


/*
 * PrintStmtList()
 *
 */

void PrintStmtList(stmt *fstmt)
{
    lPrintStmtList(fstmt, 0, NULL);
} // PrintStmtList

/*
 * PrintFunction()
 *
 */

void PrintFunction(Symbol *symb)
{
    const char *sname, *pname;
    char tname[100], uname[100];
    Symbol *params;

    if (symb) {
        sname = GetAtomString(atable, symb->name);
        if (symb->kind == FUNCTION_S) {
            if (symb->type) {
                FormatTypeString(tname, sizeof tname, uname, sizeof uname, symb->type->fun.rettype);
            } else {
                strcpy(tname, "NULL");
            }
            printf("%s %s%s(",tname, sname, uname);
            params = symb->details.fun.params;
            while (params) {
                pname = GetAtomString(atable, params->name);
                FormatTypeString(tname, sizeof tname, uname, sizeof uname, params->type);
                printf("%s %s%s",tname, pname, uname);
                params = params->next;
                if (params)
                    printf(", ");
            }
            printf(")\n");
            printf("{\n");
            lPrintStmtList(symb->details.fun.statements, 1, "function");
            printf("} // %s\n", sname);
        } else {
            printf("PrintFunction: Symbol \"%s\" not a function\n", sname);
        }
    } else {
        printf("<<NULL-Function-Symbol>>\n");
    }
} // PrintFunction

/*
 * BPrintFunction()
 *
 */

void BPrintFunction(Symbol *symb)
{
    const char *sname;

    if (symb) {
        sname = GetAtomString(atable, symb->name);
        if (symb->kind == FUNCTION_S) {
            printf("{\n");
            lBPrintStmtList(symb->details.fun.statements, 0);
            printf("} // %s\n", sname);
        } else {
            printf("BPrintFunction: Symbol \"%s\" not a function\n", sname);
        }
    } else {
        printf("<<NULL-Function-Symbol>>\n");
    }
} // BPrintFunction

///////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////// End of printutils.c ////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////