printutils.c

cg编译器

    if (fType) {
        strcpy(name, "");

        base = GetBase(fType);

        qualifiers = GetQualifiers(fType);
        if (qualifiers & TYPE_QUALIFIER_CONST)
            strcat(name, "const ");
        if ((qualifiers & TYPE_QUALIFIER_INOUT) == TYPE_QUALIFIER_INOUT) {
            strcat(name, "inout ");
        } else {
            if (qualifiers & TYPE_QUALIFIER_IN)
                strcat(name, "in ");
            if (qualifiers & TYPE_QUALIFIER_OUT)
                strcat(name, "out ");
        }

        category = GetCategory(fType);
        switch (category) {
        case TYPE_CATEGORY_NONE:
            strcat(name, "<<category=NONE>>");
            break;
        case TYPE_CATEGORY_SCALAR:
            strcat(name, GetBaseTypeNameString(base));
            break;
        case TYPE_CATEGORY_ARRAY:
            FormatTypeString(name, size, name2, size2, fType->arr.eltype);
            sprintf(tname, "[%d]", fType->arr.numels);
            strcat(name2, tname);
            break;
        case TYPE_CATEGORY_FUNCTION:
            strcat(name, "FUNCTION");
            break;
        case TYPE_CATEGORY_STRUCT:
            strcat(name, "struct ");
            strcat(name, GetAtomString(atable, fType->str.tag));
            break;
        case TYPE_CATEGORY_CONNECTOR:
            cid = Cg->theHAL->GetConnectorAtom(fType->str.variety);
            strcat(name, GetAtomString(atable, cid));
            strcat(name, " connector ");
            strcat(name, GetAtomString(atable, fType->str.tag));
            break;
        default:
            strcat(name, "<<bad-category>>");
            break;
        }
    } else {
        strcpy(name, "<<NULL>>");
    }
} // FormatTypeString

/*
 * FormatTypeStringRT() - Build a printable string of a type for export to the run-time.
 *
 * Arrays are shown as predefined typedefs: "float4" instead of "packed float[4]"
 *
 */

void FormatTypeStringRT(char *name, int size, char *name2, int size2, Type *fType, int Unqualified)
{
    int qualifiers, category, base, cid;
    char tname[32];
    int len, len2;

    strcpy(name2, "");
    if (fType) {
        strcpy(name, "");

        base = GetBase(fType);

        if (!Unqualified) {
            qualifiers = GetQualifiers(fType);
            if (qualifiers & TYPE_QUALIFIER_CONST)
                strcat(name, "const ");
            if ((qualifiers & TYPE_QUALIFIER_INOUT) == TYPE_QUALIFIER_INOUT) {
                strcat(name, "inout ");
            } else {
                if (qualifiers & TYPE_QUALIFIER_IN)
                    strcat(name, "in ");
                if (qualifiers & TYPE_QUALIFIER_OUT)
                    strcat(name, "out ");
            }
        }

        category = GetCategory(fType);
        switch (category) {
        case TYPE_CATEGORY_NONE:
            strcat(name, "<<category=NONE>>");
            break;
        case TYPE_CATEGORY_SCALAR:
            strcat(name, GetBaseTypeNameString(base));
            break;
        case TYPE_CATEGORY_ARRAY:
            if (IsMatrix(fType, &len, &len2)) {
                strcat(name, GetBaseTypeNameString(base));
                sprintf(tname, "%dx%d", len2, len);
                strcat(name, tname);
            } else if (IsVector(fType, &len)) {
                strcat(name, GetBaseTypeNameString(base));
                tname[0] = '0' + len;
                tname[1] = '\0';
                strcat(name, tname);
            } else {
                FormatTypeStringRT(name, size, name2, size2, fType->arr.eltype, Unqualified);
                sprintf(tname, "[%d]", fType->arr.numels);
                strcat(name2, tname);
            }
            break;
        case TYPE_CATEGORY_FUNCTION:
            strcat(name, "FUNCTION");
            break;
        case TYPE_CATEGORY_STRUCT:
            strcat(name, "struct ");
            strcat(name, GetAtomString(atable, fType->str.tag));
            break;
        case TYPE_CATEGORY_CONNECTOR:
            cid = Cg->theHAL->GetConnectorAtom(fType->str.variety);
            strcat(name, GetAtomString(atable, cid));
            strcat(name, " connector ");
            strcat(name, GetAtomString(atable, fType->str.tag));
            break;
        default:
            strcat(name, "<<bad-category>>");
            break;
        }
    } else {
        strcpy(name, "<<NULL>>");
    }
} // FormatTypeStringRT

/*
 * PrintType()
 *
 */

void PrintType(Type *fType, int level)
{
    int base, category, qualifiers, domain, cid;
    TypeList *lTypeList;

    if (fType) {
        qualifiers = GetQualifiers(fType);
        if (qualifiers & TYPE_QUALIFIER_CONST)
            printf("const ");
        if (qualifiers & TYPE_QUALIFIER_IN)
            printf("in ");
        if (qualifiers & TYPE_QUALIFIER_OUT)
            printf("out ");

        domain = GetDomain(fType);
        switch (domain) {
        case TYPE_DOMAIN_UNKNOWN:
            break;
        case TYPE_DOMAIN_UNIFORM:
            printf("uniform ");
            break;
        case TYPE_DOMAIN_VARYING:
            printf("varying ");
            break;
        default:
            printf("<<domain=%02x>>", domain >> TYPE_DOMAIN_SHIFT);
            break;
        }

        category = GetCategory(fType);
        switch (category) {
        case TYPE_CATEGORY_NONE:
            printf("<<category=NONE>>");
            break;
        case TYPE_CATEGORY_SCALAR:
            base = GetBase(fType);
            printf("%s", GetBaseTypeNameString(base));
            break;
        case TYPE_CATEGORY_ARRAY:
            PrintType(fType->arr.eltype, level);
            printf("[%d]", fType->arr.numels);
            break;
        case TYPE_CATEGORY_FUNCTION:
            printf("(");
            lTypeList = fType->fun.paramtypes;
            while (lTypeList) {
                PrintType(lTypeList->type, level);
                lTypeList = lTypeList->next;
                if (lTypeList)
                    printf(", ");
            }
            printf(")");
            break;
        case TYPE_CATEGORY_STRUCT:
            if (fType->str.tag) {
                printf("struct %s", GetAtomString(atable, fType->str.tag));
            } else {
                printf("struct");
            }
            break;
        case TYPE_CATEGORY_CONNECTOR:
            if (fType->str.tag) {
                cid = Cg->theHAL->GetConnectorAtom(fType->str.variety);
                printf("%s connector %s",
                       GetAtomString(atable, cid),
                       GetAtomString(atable, fType->str.tag));
            } else {
                printf("connector");
            }
            break;
        default:
            printf("<<category=%02x>>", category >> TYPE_CATEGORY_SHIFT);
            break;
        }
        //printf(" ");
    } else {
        printf("<<NULL-TYPE>>");
    }
} // PrintType

/*
 * PrintSymbolTree()
 *
 */

void PrintSymbolTree(Symbol *fSymb)
{
    Symbol *lSymb;
    int DoType;

    if (fSymb) {
        DoType = 1;
        PrintSymbolTree(fSymb->left);
        switch (fSymb->kind) {
        case TYPEDEF_S:
            printf("TYP: %s : %d:%d", GetAtomString(atable, fSymb->name),
                   Cg->theHAL->GetSizeof(fSymb->type), Cg->theHAL->GetAlignment(fSymb->type));
            break;
        case VARIABLE_S:
            if (fSymb->properties & SYMB_IS_PARAMETER) {
                printf("PAR: %s ", GetAtomString(atable, fSymb->name));
            } else {
                printf("VAR: %s ", GetAtomString(atable, fSymb->name));
            }
            break;
        case CONSTANT_S:
            printf("CON: %s ", GetAtomString(atable, fSymb->name));
            break;
        case FUNCTION_S:
            lSymb = fSymb;
            while (lSymb) {
                if (lSymb == fSymb) {
                    printf("FUN");
                } else {
                    printf("   ");
                }
                printf(": %s ", GetAtomString(atable, fSymb->name));
                PrintType(lSymb->type, 0);
                if (!lSymb->properties & SYMB_IS_DEFINED)
                    printf(" UNDEFINED");
                if (lSymb->properties & SYMB_IS_BUILTIN)
                    printf(" BUILTIN");
                if (lSymb->properties & SYMB_IS_INLINE_FUNCTION)
                    printf(" INLINE");
                printf("\n");
                lSymb = lSymb->details.fun.overload;
            }
            DoType = 0;
            break;
        default:
            printf("???%04x???: %s ", fSymb->kind, GetAtomString(atable, fSymb->name));
            break;
        }
        if (DoType) {
            PrintType(fSymb->type, 0);
            printf("\n");
        }
        PrintSymbolTree(fSymb->right);
    }
} // PrintSymbolTree

/*
 * PrintScopeDeclarations()
 *
 */

void PrintScopeDeclarations(void)
{
    printf("*** Scope %d definitions: ***\n", CurrentScope->level);
    PrintSymbolTree(CurrentScope->symbols);
    printf("*** End of Scope %d ***\n\n", CurrentScope->level);
} // PrintScopeDeclarations

/*
 * lPrintExpr()
 *
 */

void lPrintExpr(expr *fexpr)
{
    int ii, mask, len;
    unsigned int uval;
    char s[16], tag;

    switch (fexpr->common.kind) {
    case SYMB_N:
        printf("%s", GetAtomString(atable, fexpr->sym.symbol->name));
        break;
    case CONST_N:
        switch (fexpr->co.op) {
        case ICONST_OP:
            printf("%d", fexpr->co.val[0].i);
            break;
        case ICONST_V_OP:
            printf("{ %d", fexpr->co.val[0].i);
            len = SUBOP_GET_S(fexpr->co.subop);
            for (ii = 1; ii < len; ii++)
                printf(", %d", fexpr->co.val[ii].i);
            printf(" }");
            break;
        case BCONST_OP:
            if (fexpr->co.val[0].i == 0) {
                printf("false");
            } else if (fexpr->co.val[0].i == 1) {
                printf("true");
            } else {
                printf("<<BBCONST=%d>>", fexpr->co.val[0].i);
            }
            break;
        case BCONST_V_OP:
            printf("{ ");
            len = SUBOP_GET_S(fexpr->co.subop);
            for (ii = 0; ii < len; ii++)
                if (ii) printf(", ");
                if (fexpr->co.val[ii].i == 0) {
                    printf("false");
                } else if (fexpr->co.val[ii].i == 1) {
                    printf("true");
                } else {
                    printf("<<BBCONST=%d>>", fexpr->co.val[ii].i);
                }
            printf(" }");
            break;
        case FCONST_OP:
            printf("%.6gf", fexpr->co.val[0].f);
            break;
        case HCONST_OP:
            printf("%.6gh", fexpr->co.val[0].f);
            break;
        case XCONST_OP:
            printf("%.6gx", fexpr->co.val[0].f);
            break;
        case FCONST_V_OP:
            tag = 'f';
            goto floatvec;
        case HCONST_V_OP:
            tag = 'h';
            goto floatvec;
        case XCONST_V_OP:
            tag = 'x';
        floatvec:
            printf("{ %.6g%c", fexpr->co.val[0].f, tag);
            len = SUBOP_GET_S(fexpr->co.subop);
            for (ii = 1; ii < len; ii++)
                printf(", %.6g%c", fexpr->co.val[ii].f, tag);
            printf(" }");
            break;
        }
        break;
    case UNARY_N:
        switch (fexpr->un.op) {
        case CAST_CS_OP:
            printf("(%s) ", GetBaseTypeNameString(SUBOP_GET_T2(fexpr->un.subop)));
            break;
        case CAST_CV_OP:
            printf("(%s [%d]) ",
                   GetBaseTypeNameString(SUBOP_GET_T2(fexpr->un.subop)),
                   SUBOP_GET_S1(fexpr->un.subop));
            break;
        case CAST_CM_OP:
            printf("(%s [%d][%d]) ",
                   GetBaseTypeNameString(SUBOP_GET_T2(fexpr->un.subop)),
                   SUBOP_GET_S2(fexpr->un.subop), SUBOP_GET_S1(fexpr->un.subop));
            break;
        case VECTOR_V_OP:
            printf("{ ");
            break;
        case NEG_OP:
        case NEG_V_OP:
            printf("-");
            break;
        case POS_OP:
        case POS_V_OP:
            printf("+");
            break;
        case NOT_OP:
        case NOT_V_OP:
            printf("~");
            break;
        case BNOT_OP:
        case BNOT_V_OP:
            printf("!");
            break;
        case SWIZZLE_Z_OP:
        case SWIZMAT_Z_OP:
            break;
        case PREDEC_OP:
            printf("--");
            break;
        case PREINC_OP:
            printf("++");
            break;
        }
        lPrintExpr(fexpr->un.arg);
        switch (fexpr->un.op) {
        case SWIZZLE_Z_OP:
            mask = SUBOP_GET_MASK(fexpr->un.subop);
            ii = SUBOP_GET_S2(fexpr->un.subop);
            if (ii == 0)
                ii = 1; // var.x is scalar, not array[1]
            s[ii] = '\0';
            while (ii > 0) {
                ii--;
                s[ii] = "xyzw"[(mask >> ii*2) & 3];
            }
            printf(".%s", s);
            break;
        case SWIZMAT_Z_OP:
            mask = SUBOP_GET_MASK16(fexpr->un.subop);
            ii = SUBOP_GET_T2(fexpr->un.subop);
            if (ii == 0)
                ii = 1; // var.x is scalar, not array[1]
            s[ii*3] = '\0';
            while (ii > 0) {
                ii--;
                uval = (mask >> ii*4) & 15;
                s[ii*3] = '_';
                s[ii*3 + 1] = '0' + ((uval >> 2) & 3);
                s[ii*3 + 2] = '0' + (uval & 3);
            }
            printf(".m%s", s);
            break;
        case VECTOR_V_OP:
            printf(" }");
            break;
        case POSTDEC_OP:
            printf("--");
            break;
        case POSTINC_OP:
            printf("++");
            break;
        }
        break;
    case BINARY_N:
        lPrintExpr(fexpr->bin.left);
        switch (fexpr->bin.op) {