gen-enc.c

asn to c编译器 源代码

	  
	  
	  break;
	  
      case C_LIB:
      case C_TYPEREF:
	PrintCEncoderDefine (hdr, td);
	fprintf (hdr,"\n");
	break;
	
	case C_CHOICE:
	  PrintCEncoderPrototype (hdr, td);
	  PrintCEncoderDeclaration (src, td);
	  fprintf (src,"{\n");
	  PrintCEncoderLocals (src, td);
	  fprintf (src,"\n\n");

	// Call Enc_TableCons function here
/*	if(td->bHasTableConstraint)
	{
		fprintf (src,"\tif(!%s%s_TableCons(b, v))\n", GetEncRulePrefix(), td->cTypeDefInfo->encodeRoutineName);
		fprintf (src,"\t\treturn 0;\n\n"); 
	}
  */
	  PrintCChoiceEncodeCode (src, td, td->type, FIRST_LEVEL, valueArgNameG);
	  fprintf (src,"\treturn %s;\n\n", encodedLenVarNameG);
	  fprintf (src,"}  /* %s%sContent */", GetEncRulePrefix(),
		   td->cTypeDefInfo->encodeRoutineName);
	  fprintf (hdr,"\n\n");
	  fprintf (src,"\n\n");
	  break;
	  
      case C_STRUCT:
	PrintCEncoderPrototype (hdr, td);
	PrintCEncoderDeclaration (src, td);
	fprintf (src,"{\n");
	PrintCEncoderLocals (src, td);
	fprintf (src,"\n\n");

	// Call Enc_TableCons function here
/*	if(td->bHasTableConstraint)
	{
		fprintf (src,"\tif(!%s%s_TableCons(b, v))\n", GetEncRulePrefix(), td->cTypeDefInfo->encodeRoutineName);
		fprintf (src,"\treturn 0;\n"); 
	}
  */
	PrintCElmtsEncodeCode (src, td, td->type, td->type->basicType->a.set, FIRST_LEVEL, valueArgNameG);
	fprintf (src,"\treturn %s;\n\n", encodedLenVarNameG);
	fprintf (src,"}  /* %s%sContent */", GetEncRulePrefix(),
		 td->cTypeDefInfo->encodeRoutineName);
	fprintf (hdr,"\n\n");
	fprintf (src,"\n\n");
	break;

	
      case C_LIST:
	PrintCEncoderPrototype (hdr, td);
	fprintf (hdr,"\n\n");
	
	PrintCEncoderDeclaration (src, td);
	fprintf (src,"{\n");
	PrintCEncoderLocals (src, td);
	fprintf (src,"\n\n");

	// Call Enc_TableCons function here
//	if(td->bHasTableConstraint)
//	{
//		fprintf (src,"\tif(!%s%s_TableCons(b, v))\n", GetEncRulePrefix(), td->cTypeDefInfo->encodeRoutineName);
//		fprintf (src,"\treturn 0;\n"); 
//	}

	PrintCListEncoderCode (src, td, td->type, FIRST_LEVEL, valueArgNameG);
	fprintf (src,"\treturn %s;\n\n", listLenNameG);
	fprintf (src,"}  /* %s%sContent */", GetEncRulePrefix(), 
		 td->cTypeDefInfo->encodeRoutineName);
	fprintf (src,"\n\n");
	break;
	

	  case C_MACROTYPE:
		PrintCEncoderPrototype (hdr, td);
		PrintCEncoderDeclaration (src, td);
		fprintf (src,"{\n");
		PrintCEncoderLocals (src, td);
		fprintf (src,"\n\n");

		PrintCMacroElmtsEncodeCode (src, td, td->type, td->type->basicType->a.macroType, FIRST_LEVEL, valueArgNameG);
		fprintf (src,"\treturn %s;\n\n", encodedLenVarNameG);
		fprintf (src,"}  /* %s%sContent */", GetEncRulePrefix(), td->cTypeDefInfo->encodeRoutineName);
		fprintf (hdr,"\n\n");
		fprintf (src,"\n\n");
		  break;


      case C_NO_TYPE:
	/*            fprintf (src," sorry, unsupported type \n\n"); */
	break;
	
      default:
	fprintf (errFileG, "PrintCEncoder: ERROR - unknown c type id\n");
	break;
      }
    } 
	     
    m = m;    /* AVOIDS warning. */
}  /*  PrintCContentEncoder */
    
    
    
    /*
 * Prints prototype for encode routine in hdr file
 */
static void
PrintCEncoderPrototype PARAMS ((hdr, td),
    FILE *hdr _AND_
    TypeDef *td)
{
    CTDI *ctdi;

    ctdi =  td->cTypeDefInfo;
    //fprintf (hdr,"%s %s%sContent PROTO ((%s b, %s *v));", returnTypeG, GetEncRulePrefix(), ctdi->encodeRoutineName, bufTypeNameG, ctdi->cTypeName);
	fprintf (hdr,"%s %s%sContent(%s b,%s *v);", returnTypeG, GetEncRulePrefix(), ctdi->encodeRoutineName, bufTypeNameG, ctdi->cTypeName);

}  /*  PrintCEncoderPrototype */



/*
 * Prints declarations of encode routine for the given type def
 */
static void
PrintCEncoderDeclaration PARAMS ((src, td),
    FILE *src _AND_
    TypeDef *td)
{
    CTDI *ctdi;

	ctdi =  td->cTypeDefInfo;
//	fprintf (src,"%s\n%s%sContent PARAMS ((b, v),\n%s b _AND_\n%s *v)\n", returnTypeG, GetEncRulePrefix(), ctdi->encodeRoutineName, bufTypeNameG, ctdi->cTypeName);ctdi =  td->cTypeDefInfo;
    fprintf (src,"%s %s%sContent(%s b,%s *v)\n", returnTypeG, GetEncRulePrefix(), ctdi->encodeRoutineName, bufTypeNameG, ctdi->cTypeName);

}  /*  PrintCEncoderDeclaration */




/*
 * makes a define for type refs or primitive type renaming
 * EG:
 * TypeX ::= INTEGER --> #define BerEncodeTypeX(b,v) BerEncodeInteger(b,v)
 * TypeX ::= TypeY --> #define BerEncodeTypeX(b,v) BerEncodeTypeY(b,v)
 */
static void
PrintCEncoderDefine PARAMS ((hdr, td),
    FILE *hdr _AND_
    TypeDef *td)
{
    fprintf(hdr, "#define %s%sContent %s%sContent", 
	    GetEncRulePrefix(),  td->cTypeDefInfo->encodeRoutineName, 
	    GetEncRulePrefix(), td->type->cTypeRefInfo->encodeRoutineName);

/*
    fprintf(hdr, "#define %s%sContent( b, v)  ", GetEncRulePrefix(),
    td->cTypeDefInfo->encodeRoutineName);
    fprintf (hdr, "%s%sContent (b, v)", GetEncRulePrefix(),
    td->type->cTypeRefInfo->encodeRoutineName);
*/
}  /*  PrintCEncoderDefine */




static void
PrintCEncoderLocals PARAMS ((src, td),
    FILE *src _AND_
    TypeDef *td)
{
    fprintf (src, "\tAsnLen %s = 0;\n", encodedLenVarNameG);
    fprintf (src, "\tAsnLen %s;\n", itemLenNameG);
    fprintf (src, "\tAsnLen %s;\n", listLenNameG);
    fprintf (src, "\tvoid *%s;", listComponentNameG);

    td = td;    /* AVOIDS warning. */
}  /*  PrintCEncoderLocals */



/* Compare the tags of two NamedTypes */
static int ElmtsTagCmp(const void *a, const void *b) {
  NamedType **at = (NamedType **)a;
  NamedType **bt = (NamedType **)b;

  return CmpTags((*at)->type, (*bt)->type);
}

/*
 * runs through elmts backwards and prints
 * encoding code for each one
 */
static void
PrintCElmtsEncodeCode PARAMS ((src, td, parent, elmts, level, varName),
    FILE *src _AND_
    TypeDef *td _AND_
    Type *parent _AND_
    NamedTypeList *elmts _AND_
    int level _AND_
    char *varName)
{
    NamedType *e;
    NamedType **elmtlist;
    int i=0;

    if (elmts == NULL)
    {
        fprintf (src,"/* ERROR? - expected elmts for this type*/\n");
        return;
    }

    
    /* If the encoding rules to be used are DER and we are generating
     * an encoder for a SET, the SET must be encoded in tag order, therefore
     * we must sort the elements
     */
    if (GetEncRulesType() == DER && 
	parent->basicType->choiceId == BASICTYPE_SET) {
      
      /* Put all the elements in the array */
      elmtlist = (NamedType **)Asn1Alloc(sizeof(NamedType *) * 
					 AsnListCount(elmts));
      FOR_EACH_LIST_ELMT (e, elmts) {
	elmtlist[i]=e;
	i++;
      }

      /* Sort list */
      qsort(elmtlist, i, sizeof(NamedType*), ElmtsTagCmp);
 
      /* Generate encoders (backwards) */
      for (i--; i>=0; i--) {
	PrintCElmtEncodeCode (src, td, parent, elmtlist[i], level, varName);
      }

      /* Free list */
      Asn1Free(elmtlist);
    } else {
      /*
       * remember! encoding "backwards" so recursively traverse
       * list backwards
       */
      FOR_EACH_LIST_ELMT_RVS (e, elmts) 
	  {
		  if(e->type->basicType->choiceId == BASICTYPE_OBJECTCLASSFIELDTYPE)
		  {	// Deepak: 01/Apr/2003
			  fprintf (src, "\t/*~~~~~~~~~~~~~~~~~~ Now encode the OpenType parameter here ~~~~~~~~~~~~~~~~~~*/\n");
			PrintConstraintValueCheckingCode(src, td, e->type, e);
			fprintf (src, "\titemLen = %s[index].encode%s(b,&v->%s);\n", e->type->tableConstraint->objSetAssignment->objectSetName, e->type->typeName, e->fieldName);
			fprintf (src, "\titemLen += BEncConsLen(b,itemLen);\n");
               // RWC;NOTE;  FOR constant value name interpretation to a value for
               // RWC;NOTE;   tags may have to be interpreted before the "%s[index]"
               // RWC;NOTE;   is loaded.  (NOT SURE YET!)
			fprintf (src, "\titemLen += BEncTag1(b,UNIV,PRIM,%s[index].tag);\n", e->type->tableConstraint->objSetAssignment->objectSetName);
			fprintf (src, "\ttotalLen += itemLen;\n");
			fprintf (src, "\n");
			fprintf (src, "\t/*~~~~~~~~~~~~~~~~~~ Till Here ~~~~~~~~~~~~~~~~~~*/\n");
			fprintf (src, "\n");
			continue;
		  }
		PrintCElmtEncodeCode (src, td, parent, e, level, varName);
      }
    }

}  /* PrintCElmtsEncodeCode */



/*
 * Prints code for encoding the elmts of a SEQ or SET
 */
static void
PrintCElmtEncodeCode PARAMS ((src, td, parent, e, level, varName),
    FILE *src _AND_
    TypeDef *td _AND_
    Type *parent _AND_
    NamedType *e _AND_
    int level _AND_
    char *varName)
{
    CTRI *ctri;
    char elmtVarRef[MAX_VAR_REF];
    char idVarRef[MAX_VAR_REF];
    enum BasicTypeChoiceId tmpTypeId;
    Type *tmpType;
    NamedType *idNamedType;
    Value* value;

    if ((e->type == NULL) || (e->type->cTypeRefInfo == NULL) || (e->type->extensionAddition) )
        return;

    ctri =  e->type->cTypeRefInfo;

    /* check if meant to be encoded */
    if (!ctri->isEncDec)
        return;


    MakeVarPtrRef (genEncCRulesG, td, parent, e->type, varName, elmtVarRef);

    /* If we are currently using DER and the value of a component with the 
     * DEFAULT qualifier is the same as the default value, then we should not
     * encode that value 
     */
    if (e->type->defaultVal != NULL) {
      if (GetEncRulesType() == DER) 
	  {
		fprintf (src, "\tif(%s (%s) && (", ctri->optTestRoutineName, elmtVarRef);
		if (GetBuiltinType (e->type) == BASICTYPE_BITSTRING)
		{
		   fprintf (src, "(*%s).bitLen != ", elmtVarRef);
		}
		else
		{
		   fprintf (src, "*%s != ", elmtVarRef);
		}

		/* Get default value */
		switch(e->type->defaultVal->value->basicValue->choiceId) 
		{
		case BASICVALUE_LOCALVALUEREF:
		  value = 
		 e->type->defaultVal->value->basicValue->a.localValueRef->link->value;
		  break;
		case BASICVALUE_IMPORTVALUEREF:
		  value = 
		e->type->defaultVal->value->basicValue->a.importValueRef->link->value;
		  break;
		default:
		  value = e->type->defaultVal->value;
		}

		PrintCValueInstantiation(src, genEncCRulesG, value);
		fprintf (src, " /* DEFAULT */))\n\t{\n");
      } 
	  else 
	  {
		fprintf (src, "\tif(%s (%s))\n\t{\n", ctri->optTestRoutineName, elmtVarRef);
      }
    }

    if (e->type->optional && e->type->defaultVal == NULL)
        fprintf (src, "\tif(%s (%s))\n\t{\n", ctri->optTestRoutineName, elmtVarRef);

    PrintEocEncoders (src, td, e->type);

    switch(ctri->cTypeId)
    {
        case C_ANYDEFINEDBY:

            /* get type of 'defining' field (int/enum/oid)*/
            idNamedType = e->type->basicType->a.anyDefinedBy->link;
            tmpTypeId = GetBuiltinType (idNamedType->type);

            if (tmpTypeId == BASICTYPE_OID || tmpTypeId == BASICTYPE_RELATIVE_OID)
            {
                MakeVarPtrRef (genEncCRulesG, td, parent, idNamedType->type, varName, idVarRef);
                fprintf (src, "\tSetAnyTypeByOid(%s,%s);\n", elmtVarRef, idVarRef);
            }
            else
            {
                /* want to ref int by value not ptr */
                MakeVarValueRef (genEncCRulesG, td, parent, idNamedType->type, varName, idVarRef);
                fprintf (src, "\tSetAnyTypeByInt(%s,%s);\n", elmtVarRef, idVarRef);
            }

            /* ANY's enc's do tag and len so zap the Content suffix */
            fprintf (src, "\t%s = %s%s(b,%s);\n", itemLenNameG, 
		     GetEncRulePrefix(), ctri->encodeRoutineName, elmtVarRef);
            break;

        case C_TYPEREF:
            tmpType = GetType (e->type);

             /* NOTE: ANY DEFINED BY must be directly in the parent (not ref)*/
            if (tmpType->cTypeRefInfo->cTypeId != C_ANY)
            {
				if(tmpType->basicType->choiceId == BASICTYPE_ENUMERATED) // Deepak: 19/Apr/2003 only if added,
					fprintf (src, "\t%s = %s%sContent(b,(AsnInt *)%s);\n", itemLenNameG, GetEncRulePrefix(), ctri->encodeRoutineName, elmtVarRef);
				else
					fprintf (src, "\t%s = %s%sContent(b,%s);\n", itemLenNameG, GetEncRulePrefix(), ctri->encodeRoutineName, elmtVarRef);
                break;
            }
            else  /* fall through */

        case C_ANY:
            /* ANY's enc's do tag and len so zap the Content suffix */
            //RWC;fprintf (src,"\t /* ANY - Fix Me! */\n");
            fprintf (src,"\tSetAnyTypeUnknown(%s);\n", elmtVarRef);
            //RWC;fprintf (src,"\tSetAnyTypeBy\?\?\?(%s, \?\?\?);\n", elmtVarRef);
            fprintf (src,"\t%s = %s%s (b, %s);\n", itemLenNameG, 
		     GetEncRulePrefix(), "EncAsnAny"/*RWC;NOT VALID FOR C_TYPEREF;ctri->encodeRoutineName*/, elmtVarRef);
            break;


        case C_LIB:
			fprintf (src, "\t%s = %s%sContent(b,%s);\n", itemLenNameG, 
		   GetEncRulePrefix(), ctri->encodeRoutineName, elmtVarRef);
	  break;

        case C_CHOICE:
            PrintCChoiceEncodeCode (src, td, e->type, level+1, elmtVarRef);
            break;

        case C_STRUCT:
            PrintCElmtsEncodeCode (src, td, e->type, e->type->basicType->a.set, level+1, elmtVarRef);
            break;

        case C_LIST:
            PrintCListEncoderCode (src, td, e->type, level+1, elmtVarRef);
            fprintf (src, "\t%s = %s;\n", itemLenNameG, listLenNameG);
            fprintf (src,"\n");
            break;

        case C_NO_TYPE:
            break;

//		case C_OBJECTCLASSFIELDTYPE:
//		  fprintf (src, "\t%s = %s%sContent (b, %s);\n", itemLenNameG,
//			   GetEncRulePrefix(), "AsnOcts" /*ctri->encodeRoutineName*/, elmtVarRef);
//			break;

        default:
            fprintf (errFileG, "PrintCElmtEncodeCode: ERROR - unknown c type id\n");
            break;
    }

    /*RWC;NOT ANY LONGER;if (ctri->cTypeId != C_ANY) / * ANY's do their own tag/lens */
    {
        PrintCTagAndLenEncodingCode (src, td, e->type);
        fprintf (src,"\t%s += %s;\n", encodedLenVarNameG, itemLenNameG);
    }

    if (e->type->optional || (e->type->defaultVal != NULL))
        fprintf (src, "\t}\n");

    fprintf (src,"\n");

}  /*  PrintCElmtEncodeCode */

/*
 * checks for which macroType is there
 * then calls specific function for encoding of that macro
 */