gen-any.c

asn to c编译器 源代码

            }
        }
    }

    FOR_EACH_LIST_ELMT (td, m->typeDefs)
    {
        if (td->anyRefs != NULL)
        {
            ctdi = td->cTypeDefInfo;
            FOR_EACH_LIST_ELMT (ar, td->anyRefs)
            {
                installedSomeHashes = TRUE;
                if (ar->id->choiceId == OIDORINT_OID)
                {
                    fprintf (src,"    %s oid%d =", r->typeConvTbl[BASICTYPE_OID].cTypeName, i++);
                    PrintCOidValue (src, r, ar->id->a.oid);
                    fprintf (src,";\n");
                }
            }
        }
    }
    fprintf (src,"\n\n");

    * now print hash init calls *
    i = 0;

    * do lib types first *
    for (j = BASICTYPE_BOOLEAN; j < BASICTYPE_MACRODEF; j++)
    {
        arl = LIBTYPE_GET_ANY_REFS (j);
        if (arl != NULL)
        {
            FOR_EACH_LIST_ELMT (ar, arl)
            {

                encRoutineName = r->typeConvTbl[j].encodeRoutineName;
                decRoutineName = r->typeConvTbl[j].decodeRoutineName;
                printRoutineName = r->typeConvTbl[j].printRoutineName;

                 *
                 * use NULL free routine for types that
                 * have empyt macros for their free routines
                 * (since the any hash tbl needs the addr of the routine)
                 *
                switch (j)
                {
                    case BASICTYPE_BOOLEAN:
                    case BASICTYPE_INTEGER:
                    case BASICTYPE_NULL:
                    case BASICTYPE_REAL:
                    case BASICTYPE_ENUMERATED:
                        freeRoutineName = "NULL";
                        break;
                    default:
                        freeRoutineName =  r->typeConvTbl[j].freeRoutineName;
                }

                if (ar->id->choiceId == OIDORINT_OID)
                    fprintf (src,"    InstallAnyByOid (%s, &oid%d, sizeof (%s), (EncodeFcn) B%s, (DecodeFcn)B%s, (FreeFcn)%s, (PrintFcn)%s);\n\n", ar->anyIdName, i++,  r->typeConvTbl[j].cTypeName, encRoutineName, decRoutineName, freeRoutineName, printRoutineName);
                else
                    fprintf (src,"    InstallAnyByInt (%s, %d, sizeof (%s), (EncodeFcn) B%s, (DecodeFcn)B%s, (FreeFcn)%s, (PrintFcn)%s);\n\n", ar->anyIdName, ar->id->a.intId, r->typeConvTbl[j].cTypeName, encRoutineName, decRoutineName, freeRoutineName, printRoutineName);
            }
        }
    }

    FOR_EACH_LIST_ELMT (td, m->typeDefs)
    {
        if (td->anyRefs != NULL)
        {
            ctdi = td->cTypeDefInfo;
            FOR_EACH_LIST_ELMT (ar, td->anyRefs)
            {
                typeId = GetBuiltinType (td->type);

                encRoutineName = ctdi->encodeRoutineName;
                decRoutineName = ctdi->decodeRoutineName;
                printRoutineName = ctdi->printRoutineName;

                 *
                 * use NULL free routine for types that
                 * have empyt macros for their free routines
                 * (since the any hash tbl needs the addr of the routine)
                 *
                switch (typeId)
                {
                    case BASICTYPE_BOOLEAN:
                    case BASICTYPE_INTEGER:
                    case BASICTYPE_NULL:
                    case BASICTYPE_REAL:
                    case BASICTYPE_ENUMERATED:
                        freeRoutineName = "NULL";
                        break;
                    default:
                        freeRoutineName = ctdi->freeRoutineName;
                }

                if (ar->id->choiceId == OIDORINT_OID)
                    fprintf (src,"    InstallAnyByOid (%s, &oid%d, sizeof (%s), (EncodeFcn) B%s, (DecodeFcn)B%s, (FreeFcn)%s, (PrintFcn)%s);\n\n", ar->anyIdName, i++, ctdi->cTypeName, encRoutineName, decRoutineName, freeRoutineName, printRoutineName);
                else
                    fprintf (src,"    InstallAnyByInt (%s, %d, sizeof (%s), (EncodeFcn) B%s, (DecodeFcn)B%s, (FreeFcn)%s, (PrintFcn)%s);\n\n", ar->anyIdName, ar->id->a.intId, ctdi->cTypeName, encRoutineName, decRoutineName, freeRoutineName, printRoutineName);
            }
        }
    }
REN -- 1/13/98 -- added the following: */
	/* first print value for OID's */
    i = 0;

    FOR_EACH_LIST_ELMT (vd, m->valueDefs)
    {
        if (vd->value != NULL)
		{
			t = vd->value->type;
			if ((GetBuiltinType(t) == BASICTYPE_MACROTYPE) &&
				(t->basicType->a.macroType->choiceId == 
				MACROTYPE_SNMPOBJECTTYPE))
			{
				bv = vd->value->basicValue;
				if (bv != NULL)
				{
					installedSomeHashes = TRUE;
					if (bv->choiceId == BASICVALUE_OID)
					{
	                    fprintf (src,"    %s oid%d =", 
							r->typeConvTbl[BASICTYPE_OID].cTypeName, i++);
		                PrintCOidValue (src, r, bv->a.oid);
			            fprintf (src,";\n");
					}
				}
            }
        }
    }
    fprintf (src,"\n\n");

    /* now print hash init calls */
    i = 0;

    FOR_EACH_LIST_ELMT (vd, m->valueDefs)
    {
        if (vd->value != NULL)
		{
			t = vd->value->type;
			if ((GetBuiltinType(t) == BASICTYPE_MACROTYPE) &&
				(t->basicType->a.macroType->choiceId == 
				MACROTYPE_SNMPOBJECTTYPE))
			{
				bv = vd->value->basicValue;
				if (bv != NULL)
				{
					strcpy (anyId, vd->definedName);
				    Dash2Underscore (anyId, strlen (anyId));
					strcat (anyId, "_ANY_ID");

					installedSomeHashes = TRUE;
					t = t->basicType->a.macroType->a.snmpObjectType->syntax;

					/* If the syntax of this any is a basic type, get the
					function pointers from the rules table. */
					if (((t->basicType->choiceId >= BASICTYPE_BOOLEAN) && 
						(t->basicType->choiceId <= BASICTYPE_SETOF)) ||
						((t->basicType->choiceId >= BASICTYPE_NUMERIC_STR) &&
						(t->basicType->choiceId <= BASICTYPE_T61_STR)))
					{
						typeId = t->basicType->choiceId;
		                encRoutineName = 
							r->typeConvTbl[typeId].encodeRoutineName;
						decRoutineName = 
							r->typeConvTbl[typeId].decodeRoutineName;
						printRoutineName = 
							r->typeConvTbl[typeId].printRoutineName;
						switch (typeId)
						{
							case BASICTYPE_BOOLEAN:
							case BASICTYPE_INTEGER:
							case BASICTYPE_NULL:
							case BASICTYPE_REAL:
							case BASICTYPE_ENUMERATED:
								freeRoutineName = "NULL";
								break;
							default:
								freeRoutineName = 
									r->typeConvTbl[typeId].freeRoutineName;
						}

						typeName = r->typeConvTbl[typeId].cTypeName;
					}
					/* Else if the syntax of this any is either a locally
					defined type or an imported type, get the function names 
					from the this type's ref info. */
					else
					{
						td = GetTypeDef(t);
						if (td != NULL)
						{
							ctdi = td->cTypeDefInfo;
							
							encRoutineName = ctdi->encodeRoutineName;
							decRoutineName = ctdi->decodeRoutineName;
							printRoutineName = ctdi->printRoutineName;
							freeRoutineName = ctdi->freeRoutineName;
							typeName = ctdi->cTypeName;
						}
						else
					        encRoutineName = NULL;
					}

					if (bv->choiceId == BASICVALUE_OID)
						fprintf(src, "    InstallAnyByOid (%s, &oid%d, ",
							anyId, i++);
					else if (bv->choiceId == BASICVALUE_INTEGER)
						fprintf(src, "    InstallAnyByInt (%s, %d, ",
							anyId, bv->a.integer);

					if (encRoutineName != NULL)
					{
						fprintf(src, "sizeof (%s), (EncodeFcn)B%s, ", typeName, 
							encRoutineName);
						fprintf(src, "(DecodeFcn)B%s, ", decRoutineName);
						if (printFree)
							fprintf(src, "(FreeFcn)%s, ", freeRoutineName);
						else
							fprintf(src, "(FreeFcn)NULL, ");
						if (printPrinters)
							fprintf(src, "(PrintFcn)%s);\n\n", printRoutineName);
						else
							fprintf(src, "(PrintFcn)NULL);\n\n");
					}
					else
						fprintf(src, "*** ERROR *** Unknown ANY\n\n");
				}
            }
        }
    }
/* REN -- end */

    if (!installedSomeHashes)
    {
        fprintf (src,"    /* Since no INTEGER/OID to ANY type relations were defined\n");
        fprintf (src,"     * (usually done via MACROs) you must manually do the code\n");
        fprintf (src,"     * to fill the hash tbl.\n");
        fprintf (src,"     * if the ids are INTEGER use the following:\n");
        fprintf (src,"     * InstallAnyByInt (??_ANY_ID, intVal, sizeof (Foo), (EncodeFcn) %sEncFoo, (DecodeFcn)%sDecFoo, (FreeFcn)FreeFoo, (PrintFcn)PrintFoo);\n", GetEncRulePrefix(), GetEncRulePrefix());
        fprintf (src,"     * if the ids are OBJECT IDENTIFIERs use the following:\n");
        fprintf (src,"     *     InstallAnyByOid (??_ANY_ID, oidVal, sizeof (Foo), (EncodeFcn) %sEncFoo, (DecodeFcn)%sDecFoo, (FreeFcn)FreeFoo, (PrintFcn)PrintFoo);\n", GetEncRulePrefix(), GetEncRulePrefix());
        fprintf (src,"     * put the ??_ANY_IDs in the AnyId enum.\n\n");
        fprintf (src,"     * For example if you have some thing like\n");
        fprintf (src,"     * T1 ::= SEQUENCE { id INTEGER, ANY DEFINED BY id }\n");
        fprintf (src,"     * and the id 1 maps to the type BOOLEAN use the following:\n");
        fprintf (src,"     * InstallAnyByInt (SOMEBOOL_ANY_ID, 1, sizeof (AsnBool), (EncodeFcn) %sEncAsnBool, (DecodeFcn)%sDecAsnBool, (FreeFcn)NULL, (PrintFcn)PrintAsnBool);;\n", GetEncRulePrefix(), GetEncRulePrefix());
        fprintf (src,"     */\n ???????\n");  /* generate compile error */
    }

    fprintf (src,"}  /* InitAny%s */\n\n\n", modName);

    Free (modName);

    printDecoders = printDecoders;
    printEncoders = printEncoders;
    mods = mods; /* AVOIDS warnings. */
}  /* PrintAnyHashInitRoutine */

/* REN -- 1/13/98 -- GetTypeDef() function added to return the type def info
for the given type. */
TypeDef*
GetTypeDef PARAMS ((t),
    Type *t)
{
    if (t == NULL)
		return NULL;

	switch (t->basicType->choiceId)
    {
        case BASICTYPE_LOCALTYPEREF:
        case BASICTYPE_IMPORTTYPEREF:
			return t->basicType->a.localTypeRef->link;
            break;

        default:
            return NULL;
    }
    /*fprintf (fHandle, "GetTypeDef: ERROR - cannot get type def for unlinked local/import type refs\n");
    return NULL;*/

}  /* GetTypeDef */
/* REN -- end */