[apple/security.git] / SecuritySNACCRuntime / compiler / core / gen-tbls.c

/*
 * compiler/core/gen_tbls.c
 *
 * generates type tables and writes them to a file.
 *
 * MS
 * 93/02/07
 *
 * Copyright (C) 1993 Michael Sample
 *            and the University of British Columbia
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * $Header: /cvs/root/Security/SecuritySNACCRuntime/compiler/core/Attic/gen-tbls.c,v 1.1 2001/06/20 21:27:57 dmitch Exp $
 * $Log: gen-tbls.c,v $
 * Revision 1.1  2001/06/20 21:27:57  dmitch
 * Adding missing snacc compiler files.
 *
 * Revision 1.1.1.1  1999/03/16 18:06:48  aram
 * Originals from SMIME Free Library.
 *
 * Revision 1.5  1997/06/19 09:17:16  wan
 * Added isPdu flag to tables. Added value range checks during parsing.
 *
 * Revision 1.4  1997/05/07 15:18:34  wan
 * Added (limited) size constraints, bitstring and enumeration names to tables
 *
 * Revision 1.3  1995/07/25 19:41:28  rj
 * changed `_' to `-' in file names.
 *
 * Revision 1.2  1994/09/01  00:33:41  rj
 * snacc_config.h removed.
 *
 * Revision 1.1  1994/08/28  09:49:10  rj
 * first check-in. for a list of changes to the snacc-1.1 distribution please refer to the ChangeLog.
 *
 */

#include <stdio.h>

#include "asn-incl.h"
#include "asn1module.h"
#include "tbl.h"
#include "gen-tbls.h"

extern Module *usefulTypeModG;

/* non-exported routine protos */
void GenTypeDefIds  PROTO ((TBL *tbl, Module *m));
int  GenTblModule   PROTO ((TBL *tbl, Module *m, TBLModule **newTbl));
int  GenTblTypeDefs PROTO ((TBL *tbl, Module *m, TBLModule *tblMod));
int  GenTblTypes    PROTO ((TBL *tbl, Module *m, TBLModule *tblMod, TypeDef *td, TBLTypeDef *tblTd));
TBLType *GenTblTypesRec PROTO ((TBL *tbl,Module *m, TBLModule *tblMod, TypeDef *td, TBLTypeDef *tblTd, Type *t));


static int abortTblTypeDefG;
static int tblTypesTotalG;
static int tblTagsTotalG;
static int tblStringsTotalG;
static int tblStringLenTotalG;

static int tableFileVersionG;

void
GenTypeTbls PARAMS ((mods, fileName, tableFileVersion),
    ModuleList *mods _AND_
    char *fileName _AND_
    int tableFileVersion)
{
    TBL tbl;
    TBLModule *newTblMod;
    FILE *tblFile;
    ExpBuf *buf;
    ExpBuf *tmpBuf;
    Module *m;

    tableFileVersionG = tableFileVersion;

    tbl.modules = AsnListNew (sizeof (void*));
    tbl.totalNumModules = 0;
    tbl.totalNumTypeDefs = 0;
    tbl.totalNumTypes = 0;
    tbl.totalNumTags = 0;
    tbl.totalNumStrings = 0;
    tbl.totalLenStrings = 0;

    /*
     * Give each type def a unique id
     * Id is stored in TypeDef's "tmpRefCount" since
     * it was only used in the recursion pass.
     * Also updates tbl.totalNumModules and
     * tbl.totalNumTypeDefs appropriately
     */
    FOR_EACH_LIST_ELMT (m, mods)
    {
        GenTypeDefIds (&tbl, m);
    }

    /* number useful types if they are there any */
    if (usefulTypeModG != NULL)
        GenTypeDefIds (&tbl, usefulTypeModG);

    /* convert each module from parse format to simpler table format */
    FOR_EACH_LIST_ELMT (m, mods)
    {
        if (!GenTblModule (&tbl, m, &newTblMod))
        {
            fprintf (stderr,"ERROR: type table generator failed for module \"%s\", so file \"%s\" will not be written.\n", m->modId->name, fileName);
            return;
        }
    }

    /*
     *  convert useful type mod from parse format to
     *  simpler table format, if one was given
     */
    if (usefulTypeModG != NULL)
    {
        if (!GenTblModule (&tbl, usefulTypeModG, &newTblMod))
        {
            fprintf (stderr,"ERROR: type table generator failed for useful types module, file \"%s\" will not be written.\n",fileName);
            return;
        }
        /* mark the module as useful */
        newTblMod->isUseful = TRUE;
    }

    /* encode the TBLModules */
    ExpBufInit (1024);
    buf = ExpBufAllocBufAndData();

    BEncTBL (&buf, &tbl);

    if (ExpBufWriteError (&buf))
    {
        fprintf (stderr,"ERROR: buffer write error during encoding of type table.\n", fileName);
        return;
    }


    /* open & truncate or create as file with given filename */
    tblFile = fopen (fileName,"w");

    if (tblFile == NULL)
    {
        fprintf (stderr,"ERROR: Could not open file \"%s\" for the type table.\n", fileName);
        return;
    }


    /*
     * go through buffer (s) and write encoded value
     * to stdout
     */
    buf->curr = buf->dataStart;
    for (tmpBuf = buf; tmpBuf != NULL; tmpBuf = tmpBuf->next)
    {
        fwrite (tmpBuf->dataStart, tmpBuf->dataEnd - tmpBuf->dataStart, 1, tblFile);
    }

    fclose (tblFile);

} /* GenTypeTbls */


/*
 * The typeDefIds start at zero.  They are used as "portable"
 * pointers.  Each TBLTypeDef has a unique typeDefId.
 * The typeDefIds in a given TBLModule will be consecutive
 * and increasing from the first typedef to the last.
 *
 * This routine gives each type def in the given module a unique
 * integer identifier.
 * This id is temporarily stored in the tmpRefCount field of the TypeDef
 * (in the big parse tree).  The typeDefId is transfered
 * to the TBL data structure after this.
 *
 * tbl.totalNumModules and tbl.totalNumTypeDefs are updated.
 *
 * ASSUMES: that tbl->totalNumModules is initialized to zero
 *          and that tbl->totalNumTypeDefs is initialized to zero
 *          on the first call to this routine.
 *          This allows subsequent calls to give out the proper ids
 *          to the types in the next module.
 *
 *  (the type ids range from 0 to tbl->totalNumTypeDefs-1 (inclusive))
 */
void
GenTypeDefIds PARAMS ((tbl,m),
    TBL *tbl _AND_
    Module *m)
{
    TypeDef *td;

    tbl->totalNumModules++;
    FOR_EACH_LIST_ELMT (td, m->typeDefs)
    {
        td->tmpRefCount = tbl->totalNumTypeDefs;
        tbl->totalNumTypeDefs++;
    }

} /* GenTypeDefIds */


/*
 * builds a TBLModule from the given module and appends it to
 * the given TBL's module list.  Also updates the TBLs
 * totals for modules, tags, typedefs and types.
 * Returns TRUE is succeeded. FALSE is failed.
 */
int
GenTblModule PARAMS ((tbl, m, newTblMod),
    TBL *tbl _AND_
    Module *m _AND_
    TBLModule **newTblMod)
{
    TBLModule **mHndl;
    TBLModule *tblMod;
    int eLen;
    AsnOid *result;

    mHndl = AsnListAppend (tbl->modules);

    tblMod = MT (TBLModule);
    *newTblMod = *mHndl = tblMod;

    /* copy the name */
    tblMod->name.octetLen = strlen (m->modId->name);
    tblMod->name.octs = Malloc (tblMod->name.octetLen + 1);
    strcpy (tblMod->name.octs, m->modId->name);
    tbl->totalNumStrings++;
    tbl->totalLenStrings += tblMod->name.octetLen;

    /* copy the OBJECT IDENTIFIER (if any) */
    if (m->modId->oid != NULL)
    {
        /* convert the (linked) OID into a (encoded) AsnOid */
        if (FlattenLinkedOid (m->modId->oid))
        {
            eLen = EncodedOidLen (m->modId->oid);
            tblMod->id.octetLen = eLen;
            tblMod->id.octs = (char*)Malloc (eLen);
            BuildEncodedOid (m->modId->oid, &tblMod->id);
            tbl->totalNumStrings++;
            tbl->totalLenStrings += eLen;
        }
    }

    /*
     * useful defaults to false
     * (ie assume the it is not the usefultypes modules)
     */
    tblMod->isUseful = FALSE;

    /* now copy each of the type defs */
    return GenTblTypeDefs (tbl, m, tblMod);

} /* GenTblModule */


/*
 * converts typeDefs in Module format to TBLModule format
 * returns TRUE for success, FALSE for failure.
 */
int
GenTblTypeDefs PARAMS ((tbl, m, tblMod),
    TBL *tbl _AND_
    Module *m _AND_
    TBLModule *tblMod)
{
    TypeDef *td;
    TBLTypeDef **tblTdHndl;
    TBLTypeDef *tblTd;
    int isOk = TRUE;  /* init to no errors */

    tblMod->typeDefs = AsnListNew (sizeof (void*));
    FOR_EACH_LIST_ELMT (td, m->typeDefs)
    {

        tblTd = MT (TBLTypeDef);

        /* set type def id */
        tblTd->typeDefId = td->tmpRefCount;

        /* copy type def name */
        tblTd->typeName.octetLen = strlen (td->definedName);
        tblTd->typeName.octs = Malloc (tblTd->typeName.octetLen + 1);
        strcpy (tblTd->typeName.octs, td->definedName);
        tbl->totalNumStrings++;
        tbl->totalLenStrings += tblTd->typeName.octetLen;

/*
	if (td->isPdu)
	    tblTd->isPdu = MT (AsnNull);
*/
	if (m!=usefulTypeModG)
	{
	    MyString attr;
	    char* attrName;
	    char* attrValue;
	    int result = FALSE;
	    FOR_EACH_LIST_ELMT(attr,td->attrList)
	    {
		int loc = 0;
		while (TRUE) 
		{
		    ParseAttr(attr,&loc,&attrName,&attrValue);
		    if (!attrName)
			break;
		    if (!strcmp(attrName,"isPdu"))
			if (ParseBool(attrValue,&result)<0)
			    fprintf(stderr,"Warning: ignoring attribute with improper value (%s/%s)\n",attrName,attrValue);
		    Free(attrValue);
		}
	    }
	    if (result)
		tblTd->isPdu = MT (AsnNull);
	}


        /* fill in type portion */
        if (!GenTblTypes (tbl, m, tblMod, td, tblTd) && !abortTblTypeDefG)
            isOk = FALSE;


        /*
         * add TBLtypeDef to TBLModule
         * if no weird types were found
         * (weird types are skipped)
         */
        if (!abortTblTypeDefG)
        {
            tblTdHndl = AsnListAppend (tblMod->typeDefs);
            *tblTdHndl = tblTd;
            tbl->totalNumTypes += tblTypesTotalG;
            tbl->totalNumTags += tblTagsTotalG;
            tbl->totalNumStrings += tblStringsTotalG;
            tbl->totalLenStrings += tblStringLenTotalG;
        }
        /* else could free it */

    }
    return isOk;
} /* GenTblTypeDefs */


/*
 * converts Module Type to a TBLModule Type.  attaches converted
 * type info to the given tblTd.
 * Returns TRUE for success, FALSE for failure.
 */
int
GenTblTypes PARAMS ((tbl, m, tblMod, td, tblTd),
    TBL *tbl _AND_
    Module *m _AND_
    TBLModule *tblMod _AND_
    TypeDef *td _AND_
    TBLTypeDef *tblTd)
{
    abortTblTypeDefG = FALSE;
    tblTypesTotalG = 0;
    tblTagsTotalG = 0;
    tblStringsTotalG = 0;
    tblStringLenTotalG = 0;

    tblTd->type = GenTblTypesRec (tbl, m, tblMod, td, tblTd, td->type);

    if (tblTd->type == NULL)
        return FALSE; /* failed */
    else
        return TRUE;

} /* GenTblTypes */

BasicValue* 
GetTblValue PARAMS ((v),
    Value* v)
{
    switch (v->basicValue->choiceId)
    {
	case BASICVALUE_INTEGER:
	    return v->basicValue;
	default:
	    return NULL;
    }
}

enum BasicTypeChoiceId 
GetTblBasicType PARAMS ((bt),
    BasicType* bt)
{
    switch (bt->choiceId)
    {
    case BASICTYPE_LOCALTYPEREF:
    case BASICTYPE_IMPORTTYPEREF:
	return GetTblBasicType (bt->a.localTypeRef->link->type->basicType);
    default:
	return bt->choiceId;
    }
}

TBLRange*
GenTblValueRange PARAMS ((tbl, m, tblMod, s, doSize),
    TBL *tbl _AND_
    Module *m _AND_
    TBLModule *tblMod _AND_
    Subtype *s _AND_
    int doSize)
{
    TBLRange* range;
    BasicValue* from;
    BasicValue* to;

    if (tableFileVersionG<=1)
	return NULL;

    switch (s->choiceId) 
    {
	case SUBTYPE_SINGLE:
	    switch (s->a.single->choiceId)
	    {
		case SUBTYPEVALUE_SINGLEVALUE:
		    if (doSize)
			return NULL;
		    from = to = GetTblValue (s->a.single->a.singleValue);
		    break;
		case SUBTYPEVALUE_VALUERANGE:
		    if (doSize)
			return NULL;
		    from =GetTblValue(s->a.single->a.valueRange->lowerEndValue);
		    to = GetTblValue (s->a.single->a.valueRange->upperEndValue);
		    break;
		case SUBTYPEVALUE_SIZECONSTRAINT:
		    if (!doSize)
			return NULL;
		    return GenTblValueRange (tbl, m, tblMod, 
			    s->a.single->a.sizeConstraint, 0);
		    break;
		default:
		    return NULL;
	    }
	    break;
	case SUBTYPE_AND:
	    if (s->a.and && LIST_COUNT(s->a.and)==1)
		return GenTblValueRange (tbl, m, tblMod,
			FIRST_LIST_ELMT(s->a.and), doSize);
	    return NULL;
	case SUBTYPE_OR:
	    if (s->a.and && LIST_COUNT(s->a.or)==1)
		return GenTblValueRange (tbl, m, tblMod,
			FIRST_LIST_ELMT(s->a.or), doSize);
	    return NULL;
	case SUBTYPE_NOT:
	    return NULL;
    }
    if (!from || !to)
	return NULL;
    range = MT (TBLRange);
    range->from = from->a.integer;
    range->to = to->a.integer;
    return range;
}

TBLNamedNumberList*
GenTblValues PARAMS ((tbl, m, tblMod, list),
    TBL *tbl _AND_
    Module *m _AND_
    TBLModule *tblMod _AND_
    NamedNumberList* list)
{
    TBLNamedNumberList* tnnl = NULL;

    if (tableFileVersionG<=1)
	return NULL;

    if (list && !LIST_EMPTY(list))
    {
	ValueDef* vd;
	tnnl = (TBLNamedNumberList*) AsnListNew(sizeof(void*));
	FOR_EACH_LIST_ELMT(vd,list)
	{
	    BasicValue* bv = GetTblValue(vd->value);
	    if (bv)
	    {
		TBLNamedNumber* tnn = MT(TBLNamedNumber);
		*(TBLNamedNumber**)AsnListAppend(tnnl) = tnn;
		tnn->value = bv->a.integer;
		if (vd->definedName)
		{
		    tnn->name.octetLen = strlen(vd->definedName);
		    tnn->name.octs = Malloc(tnn->name.octetLen+1);
		    strcpy(tnn->name.octs,vd->definedName);
		    tblStringsTotalG++;
		    tblStringLenTotalG += tnn->name.octetLen;
		}
	    }
	}

    }
    return tnnl;
}

TBLType*
GenTblTypesRec PARAMS ((tbl, m, tblMod, td, tblTd, t),
    TBL *tbl _AND_
    Module *m _AND_
    TBLModule *tblMod _AND_
    TypeDef *td _AND_
    TBLTypeDef *tblTd _AND_
    Type *t)
{
    TBLType *tblT;
    NamedType *e;
    TBLType **tblTHndl;
    Tag *tag;
    TBLTag **tblTagHndl;

    tblTypesTotalG++;
    tblT = MT (TBLType);
    tblT->content = MT (TBLTypeContent);
    switch (t->basicType->choiceId)
    {
      case BASICTYPE_BOOLEAN:
          tblT->typeId = TBL_BOOLEAN;
          tblT->content->choiceId = TBLTYPECONTENT_PRIMTYPE;
          break;

      case BASICTYPE_INTEGER:
          tblT->typeId = TBL_INTEGER;
          tblT->content->choiceId = TBLTYPECONTENT_PRIMTYPE;
          break;

      case BASICTYPE_BITSTRING:
          tblT->typeId = TBL_BITSTRING;
          tblT->content->choiceId = TBLTYPECONTENT_PRIMTYPE;
	  tblT->values = GenTblValues(tbl,m,tblMod,t->basicType->a.bitString);
          break;

      case BASICTYPE_OCTETSTRING:
          tblT->typeId = TBL_OCTETSTRING;
          tblT->content->choiceId = TBLTYPECONTENT_PRIMTYPE;
	  if (t->subtypes)
	      tblT->constraint = GenTblValueRange(tbl, m, tblMod,t->subtypes,1);
          break;

      case BASICTYPE_NULL:
          tblT->typeId = TBL_NULL;
          tblT->content->choiceId = TBLTYPECONTENT_PRIMTYPE;
          break;

      case BASICTYPE_OID:
          tblT->typeId = TBL_OID;
          tblT->content->choiceId = TBLTYPECONTENT_PRIMTYPE;
          break;

      case BASICTYPE_REAL:
          tblT->typeId = TBL_REAL;
          tblT->content->choiceId = TBLTYPECONTENT_PRIMTYPE;
          break;

      case BASICTYPE_ENUMERATED:
          tblT->typeId = TBL_ENUMERATED;
          tblT->content->choiceId = TBLTYPECONTENT_PRIMTYPE;
	  tblT->values = GenTblValues(tbl,m,tblMod,t->basicType->a.enumerated);
          break;

      case BASICTYPE_SEQUENCE:
          tblT->typeId = TBL_SEQUENCE;
          tblT->content->choiceId = TBLTYPECONTENT_ELMTS;
          tblT->content->a.elmts = AsnListNew (sizeof (void*));
          FOR_EACH_LIST_ELMT (e, t->basicType->a.sequence)
          {
              tblTHndl = AsnListAppend (tblT->content->a.elmts);
              *tblTHndl = GenTblTypesRec (tbl, m, tblMod, td, tblTd, e->type);

              if (*tblTHndl == NULL)
                  break;

              if (e->fieldName != NULL)
              {
                  (**tblTHndl).fieldName.octetLen = strlen (e->fieldName);
                  (**tblTHndl).fieldName.octs =
                      Malloc ((**tblTHndl).fieldName.octetLen + 1);
                  strcpy ((**tblTHndl).fieldName.octs, e->fieldName);
                  tblStringsTotalG++;
                  tblStringLenTotalG += (**tblTHndl).fieldName.octetLen;
              }

             (**tblTHndl).optional =
                 ((e->type->optional) || (e->type->defaultVal != NULL));
          }

          break;

      case BASICTYPE_SET:
          tblT->typeId = TBL_SET;
          tblT->content->choiceId = TBLTYPECONTENT_ELMTS;
          tblT->content->a.elmts = AsnListNew (sizeof (void*));
          FOR_EACH_LIST_ELMT (e, t->basicType->a.set)
          {
              tblTHndl = AsnListAppend (tblT->content->a.elmts);
              *tblTHndl = GenTblTypesRec (tbl, m, tblMod, td, tblTd, e->type);

              if (*tblTHndl == NULL)
                  break;

              if (e->fieldName != NULL)
              {
                  (**tblTHndl).fieldName.octetLen = strlen (e->fieldName);
                  (**tblTHndl).fieldName.octs =
                      Malloc ((**tblTHndl).fieldName.octetLen + 1);
                  strcpy ((**tblTHndl).fieldName.octs, e->fieldName);
                  tblStringsTotalG++;
                  tblStringLenTotalG += (**tblTHndl).fieldName.octetLen;
              }

             (**tblTHndl).optional =
                 ((e->type->optional) || (e->type->defaultVal != NULL));

          }
          break;

      case BASICTYPE_SEQUENCEOF:
          tblT->typeId = TBL_SEQUENCEOF;
          tblT->content->choiceId = TBLTYPECONTENT_ELMTS;
          tblT->content->a.elmts = AsnListNew (sizeof (void*));
          tblTHndl = AsnListAppend (tblT->content->a.elmts);
          *tblTHndl = GenTblTypesRec (tbl, m, tblMod, td, tblTd, t->basicType->a.sequenceOf);
	  if (t->subtypes)
	      tblT->constraint = GenTblValueRange(tbl, m, tblMod,t->subtypes,1);
          break;

      case BASICTYPE_SETOF:
          tblT->typeId = TBL_SETOF;
          tblT->content->choiceId = TBLTYPECONTENT_ELMTS;
          tblT->content->a.elmts = AsnListNew (sizeof (void*));
          tblTHndl = AsnListAppend (tblT->content->a.elmts);
          *tblTHndl = GenTblTypesRec (tbl, m, tblMod, td, tblTd, t->basicType->a.setOf);
	  if (t->subtypes)
	      tblT->constraint = GenTblValueRange(tbl, m, tblMod,t->subtypes,1);
          break;

      case BASICTYPE_CHOICE:
          tblT->typeId = TBL_CHOICE;
          tblT->content->choiceId = TBLTYPECONTENT_ELMTS;
          tblT->content->a.elmts = AsnListNew (sizeof (void*));
          FOR_EACH_LIST_ELMT (e, t->basicType->a.set)
          {
              tblTHndl = AsnListAppend (tblT->content->a.elmts);
              *tblTHndl = GenTblTypesRec (tbl, m, tblMod, td, tblTd, e->type);

              if (*tblTHndl == NULL)
                  break;

              if (e->fieldName != NULL)
              {
                  (**tblTHndl).fieldName.octetLen = strlen (e->fieldName);
                  (**tblTHndl).fieldName.octs =
                      Malloc ((**tblTHndl).fieldName.octetLen + 1);
                  strcpy ((**tblTHndl).fieldName.octs, e->fieldName);
                  tblStringsTotalG++;
                  tblStringLenTotalG += (**tblTHndl).fieldName.octetLen;
              }

             (**tblTHndl).optional =
                 ((e->type->optional) || (e->type->defaultVal != NULL));

          }
          break;

      case BASICTYPE_LOCALTYPEREF:
      case BASICTYPE_IMPORTTYPEREF:
          tblT->typeId = TBL_TYPEREF;
          tblT->content->choiceId = TBLTYPECONTENT_TYPEREF;
          tblT->content->a.typeRef = MT (TBLTypeRef);
          tblT->content->a.typeRef->implicit = t->implicit;
          tblT->content->a.typeRef->typeDef  =
              t->basicType->a.localTypeRef->link->tmpRefCount;
          break;

      default:
          if (!abortTblTypeDefG) /* only print first time  */
              fprintf (stderr,"WARNING: Type definition \"%s\" will not be included in the type table because it contains a weird type.\n",td->definedName);
          abortTblTypeDefG = TRUE;
          Free (tblT->content);
          Free (tblT);
          tblT = NULL;
          break;
    }

    /* handle constraints */
    if (t->subtypes)
    {
	switch (GetTblBasicType(t->basicType))
	{
	case BASICTYPE_INTEGER:
	    tblT->constraint = GenTblValueRange(tbl,m,tblMod,t->subtypes,0);
	    break;
	case BASICTYPE_OCTETSTRING:
	case BASICTYPE_SEQUENCEOF:
	    tblT->constraint = GenTblValueRange(tbl,m,tblMod,t->subtypes,1);
	    break;
	default:
	    break;
	}
    }

    /* copy the tags */
    if ((tblT != NULL) &&
        ((t->tags != NULL) && (!LIST_EMPTY (t->tags))))
    {
        tblT->tagList = AsnListNew (sizeof (void*));
        FOR_EACH_LIST_ELMT (tag, t->tags)
        {
            tblTagsTotalG++;
            tblTagHndl = AsnListAppend (tblT->tagList);
            *tblTagHndl = MT (TBLTag);
            switch (tag->tclass)
            {
              case UNIV:
                (**tblTagHndl).tclass = UNIVERSAL;
                break;
              case APPL:
                (**tblTagHndl).tclass = APPLICATION;
                break;
              case CNTX:
                (**tblTagHndl).tclass = CONTEXT;
                break;
              case PRIV:
                (**tblTagHndl).tclass = PRIVATE;
                break;
            }
            (**tblTagHndl).code = tag->code;
        }
    }

    return tblT;
} /* GenTblTypesRec */
Commit	Line	Data
bac41a7b A	1	/*
	2	* compiler/core/gen_tbls.c
	3	*
	4	* generates type tables and writes them to a file.
	5	*
	6	* MS
	7	* 93/02/07
	8	*
	9	* Copyright (C) 1993 Michael Sample
	10	* and the University of British Columbia
	11	*
	12	* This program is free software; you can redistribute it and/or modify
	13	* it under the terms of the GNU General Public License as published by
	14	* the Free Software Foundation; either version 2 of the License, or
	15	* (at your option) any later version.
	16	*
a66d0d4a	17	* $Header: /cvs/root/Security/SecuritySNACCRuntime/compiler/core/Attic/gen-tbls.c,v 1.1 2001/06/20 21:27:57 dmitch Exp $
bac41a7b A	18	* $Log: gen-tbls.c,v $
	19	* Revision 1.1 2001/06/20 21:27:57 dmitch
	20	* Adding missing snacc compiler files.
	21	*
	22	* Revision 1.1.1.1 1999/03/16 18:06:48 aram
	23	* Originals from SMIME Free Library.
	24	*
	25	* Revision 1.5 1997/06/19 09:17:16 wan
	26	* Added isPdu flag to tables. Added value range checks during parsing.
	27	*
	28	* Revision 1.4 1997/05/07 15:18:34 wan
	29	* Added (limited) size constraints, bitstring and enumeration names to tables
	30	*
	31	* Revision 1.3 1995/07/25 19:41:28 rj
	32	* changed `_' to `-' in file names.
	33	*
	34	* Revision 1.2 1994/09/01 00:33:41 rj
	35	* snacc_config.h removed.
	36	*
	37	* Revision 1.1 1994/08/28 09:49:10 rj
	38	* first check-in. for a list of changes to the snacc-1.1 distribution please refer to the ChangeLog.
	39	*
	40	*/
	41
	42	#include <stdio.h>
	43
	44	#include "asn-incl.h"
	45	#include "asn1module.h"
	46	#include "tbl.h"
	47	#include "gen-tbls.h"
	48
	49	extern Module *usefulTypeModG;
	50
	51	/* non-exported routine protos */
	52	void GenTypeDefIds PROTO ((TBL tbl, Module m));
	53	int GenTblModule PROTO ((TBL tbl, Module m, TBLModule **newTbl));
	54	int GenTblTypeDefs PROTO ((TBL tbl, Module m, TBLModule *tblMod));
	55	int GenTblTypes PROTO ((TBL tbl, Module m, TBLModule tblMod, TypeDef td, TBLTypeDef *tblTd));
	56	TBLType GenTblTypesRec PROTO ((TBL tbl,Module m, TBLModule tblMod, TypeDef td, TBLTypeDef tblTd, Type *t));
	57
	58
	59	static int abortTblTypeDefG;
	60	static int tblTypesTotalG;
	61	static int tblTagsTotalG;
	62	static int tblStringsTotalG;
	63	static int tblStringLenTotalG;
	64
	65	static int tableFileVersionG;
	66
	67	void
	68	GenTypeTbls PARAMS ((mods, fileName, tableFileVersion),
	69	ModuleList *mods _AND_
	70	char *fileName _AND_
	71	int tableFileVersion)
	72	{
	73	TBL tbl;
	74	TBLModule *newTblMod;
	75	FILE *tblFile;
	76	ExpBuf *buf;
	77	ExpBuf *tmpBuf;
	78	Module *m;
	79
	80	tableFileVersionG = tableFileVersion;
	81
82	tbl.modules = AsnListNew (sizeof (void*));
83	tbl.totalNumModules = 0;
84	tbl.totalNumTypeDefs = 0;
85	tbl.totalNumTypes = 0;
86	tbl.totalNumTags = 0;
87	tbl.totalNumStrings = 0;
88	tbl.totalLenStrings = 0;
89
90	/*
91	* Give each type def a unique id
92	* Id is stored in TypeDef's "tmpRefCount" since
93	* it was only used in the recursion pass.
94	* Also updates tbl.totalNumModules and
95	* tbl.totalNumTypeDefs appropriately
96	*/
97	FOR_EACH_LIST_ELMT (m, mods)
98	{
99	GenTypeDefIds (&tbl, m);
100	}
101
102	/* number useful types if they are there any */
103	if (usefulTypeModG != NULL)
104	GenTypeDefIds (&tbl, usefulTypeModG);
105
106	/* convert each module from parse format to simpler table format */
107	FOR_EACH_LIST_ELMT (m, mods)
108	{
109	if (!GenTblModule (&tbl, m, &newTblMod))
110	{
111	fprintf (stderr,"ERROR: type table generator failed for module \"%s\", so file \"%s\" will not be written.\n", m->modId->name, fileName);
112	return;
113	}
114	}
115
116	/*
117	* convert useful type mod from parse format to
118	* simpler table format, if one was given
119	*/
120	if (usefulTypeModG != NULL)
121	{
122	if (!GenTblModule (&tbl, usefulTypeModG, &newTblMod))
123	{
124	fprintf (stderr,"ERROR: type table generator failed for useful types module, file \"%s\" will not be written.\n",fileName);
125	return;
126	}
127	/* mark the module as useful */
128	newTblMod->isUseful = TRUE;
129	}
130
131	/* encode the TBLModules */
132	ExpBufInit (1024);
133	buf = ExpBufAllocBufAndData();
134
135	BEncTBL (&buf, &tbl);
136
137	if (ExpBufWriteError (&buf))
138	{
139	fprintf (stderr,"ERROR: buffer write error during encoding of type table.\n", fileName);
140	return;
141	}
142
143
144	/* open & truncate or create as file with given filename */
145	tblFile = fopen (fileName,"w");
146
147	if (tblFile == NULL)
148	{
149	fprintf (stderr,"ERROR: Could not open file \"%s\" for the type table.\n", fileName);
150	return;
151	}
152
153
154	/*
155	* go through buffer (s) and write encoded value
156	* to stdout
157	*/
158	buf->curr = buf->dataStart;
159	for (tmpBuf = buf; tmpBuf != NULL; tmpBuf = tmpBuf->next)
160	{
161	fwrite (tmpBuf->dataStart, tmpBuf->dataEnd - tmpBuf->dataStart, 1, tblFile);
162	}
163
164	fclose (tblFile);
165
166	} /* GenTypeTbls */
167
168
169	/*
170	* The typeDefIds start at zero. They are used as "portable"
171	* pointers. Each TBLTypeDef has a unique typeDefId.
172	* The typeDefIds in a given TBLModule will be consecutive
173	* and increasing from the first typedef to the last.
174	*
175	* This routine gives each type def in the given module a unique
176	* integer identifier.
177	* This id is temporarily stored in the tmpRefCount field of the TypeDef
178	* (in the big parse tree). The typeDefId is transfered
179	* to the TBL data structure after this.
180	*
181	* tbl.totalNumModules and tbl.totalNumTypeDefs are updated.
182	*
183	* ASSUMES: that tbl->totalNumModules is initialized to zero
184	* and that tbl->totalNumTypeDefs is initialized to zero
185	* on the first call to this routine.
186	* This allows subsequent calls to give out the proper ids
187	* to the types in the next module.
188	*
189	* (the type ids range from 0 to tbl->totalNumTypeDefs-1 (inclusive))
190	*/
191	void
192	GenTypeDefIds PARAMS ((tbl,m),
193	TBL *tbl _AND_
194	Module *m)
195	{
196	TypeDef *td;
197
198	tbl->totalNumModules++;
199	FOR_EACH_LIST_ELMT (td, m->typeDefs)
200	{
201	td->tmpRefCount = tbl->totalNumTypeDefs;
202	tbl->totalNumTypeDefs++;
203	}
204
205	} /* GenTypeDefIds */
206
207
208	/*
209	* builds a TBLModule from the given module and appends it to
210	* the given TBL's module list. Also updates the TBLs
211	* totals for modules, tags, typedefs and types.
212	* Returns TRUE is succeeded. FALSE is failed.
213	*/
214	int
215	GenTblModule PARAMS ((tbl, m, newTblMod),
216	TBL *tbl _AND_
217	Module *m _AND_
218	TBLModule **newTblMod)
219	{
220	TBLModule **mHndl;
221	TBLModule *tblMod;
222	int eLen;
223	AsnOid *result;
224
225	mHndl = AsnListAppend (tbl->modules);
226
227	tblMod = MT (TBLModule);
228	newTblMod = mHndl = tblMod;
229
230	/* copy the name */
231	tblMod->name.octetLen = strlen (m->modId->name);
232	tblMod->name.octs = Malloc (tblMod->name.octetLen + 1);
233	strcpy (tblMod->name.octs, m->modId->name);
234	tbl->totalNumStrings++;
235	tbl->totalLenStrings += tblMod->name.octetLen;
236
237	/* copy the OBJECT IDENTIFIER (if any) */
238	if (m->modId->oid != NULL)
239	{
240	/* convert the (linked) OID into a (encoded) AsnOid */
241	if (FlattenLinkedOid (m->modId->oid))
242	{
243	eLen = EncodedOidLen (m->modId->oid);
244	tblMod->id.octetLen = eLen;
245	tblMod->id.octs = (char*)Malloc (eLen);
246	BuildEncodedOid (m->modId->oid, &tblMod->id);
247	tbl->totalNumStrings++;
248	tbl->totalLenStrings += eLen;
249	}
250	}
251
252	/*
253	* useful defaults to false
254	* (ie assume the it is not the usefultypes modules)
255	*/
256	tblMod->isUseful = FALSE;
257
258	/* now copy each of the type defs */
259	return GenTblTypeDefs (tbl, m, tblMod);
260
261	} /* GenTblModule */
262
263
264	/*
265	* converts typeDefs in Module format to TBLModule format
266	* returns TRUE for success, FALSE for failure.
267	*/
268	int
269	GenTblTypeDefs PARAMS ((tbl, m, tblMod),
270	TBL *tbl _AND_
271	Module *m _AND_
272	TBLModule *tblMod)
273	{
274	TypeDef *td;
275	TBLTypeDef **tblTdHndl;
276	TBLTypeDef *tblTd;
277	int isOk = TRUE; /* init to no errors */
278
279	tblMod->typeDefs = AsnListNew (sizeof (void*));
280	FOR_EACH_LIST_ELMT (td, m->typeDefs)
281	{
282
283	tblTd = MT (TBLTypeDef);
284
285	/* set type def id */
286	tblTd->typeDefId = td->tmpRefCount;
287
288	/* copy type def name */
289	tblTd->typeName.octetLen = strlen (td->definedName);
290	tblTd->typeName.octs = Malloc (tblTd->typeName.octetLen + 1);
291	strcpy (tblTd->typeName.octs, td->definedName);
292	tbl->totalNumStrings++;
293	tbl->totalLenStrings += tblTd->typeName.octetLen;
294
295	/*
296	if (td->isPdu)
297	tblTd->isPdu = MT (AsnNull);
298	*/
299	if (m!=usefulTypeModG)
300	{
301	MyString attr;
302	char* attrName;
303	char* attrValue;
304	int result = FALSE;
305	FOR_EACH_LIST_ELMT(attr,td->attrList)
306	{
307	int loc = 0;
308	while (TRUE)
309	{
310	ParseAttr(attr,&loc,&attrName,&attrValue);
311	if (!attrName)
312	break;
313	if (!strcmp(attrName,"isPdu"))
314	if (ParseBool(attrValue,&result)<0)
315	fprintf(stderr,"Warning: ignoring attribute with improper value (%s/%s)\n",attrName,attrValue);
316	Free(attrValue);
317	}
318	}
319	if (result)
320	tblTd->isPdu = MT (AsnNull);
321	}
322
323
324	/* fill in type portion */
325	if (!GenTblTypes (tbl, m, tblMod, td, tblTd) && !abortTblTypeDefG)
326	isOk = FALSE;
327
328
329	/*
330	* add TBLtypeDef to TBLModule
331	* if no weird types were found
332	* (weird types are skipped)
333	*/
334	if (!abortTblTypeDefG)
335	{
336	tblTdHndl = AsnListAppend (tblMod->typeDefs);
337	*tblTdHndl = tblTd;
338	tbl->totalNumTypes += tblTypesTotalG;
339	tbl->totalNumTags += tblTagsTotalG;
340	tbl->totalNumStrings += tblStringsTotalG;
341	tbl->totalLenStrings += tblStringLenTotalG;
342	}
343	/* else could free it */
344
345	}
346	return isOk;
347	} /* GenTblTypeDefs */
348
349
350	/*
351	* converts Module Type to a TBLModule Type. attaches converted
352	* type info to the given tblTd.
353	* Returns TRUE for success, FALSE for failure.
354	*/
355	int
356	GenTblTypes PARAMS ((tbl, m, tblMod, td, tblTd),
357	TBL *tbl _AND_
358	Module *m _AND_
359	TBLModule *tblMod _AND_
360	TypeDef *td _AND_
361	TBLTypeDef *tblTd)
362	{
363	abortTblTypeDefG = FALSE;
364	tblTypesTotalG = 0;
365	tblTagsTotalG = 0;
366	tblStringsTotalG = 0;
367	tblStringLenTotalG = 0;
368
369	tblTd->type = GenTblTypesRec (tbl, m, tblMod, td, tblTd, td->type);
370
371	if (tblTd->type == NULL)
372	return FALSE; /* failed */
373	else
374	return TRUE;
375
376	} /* GenTblTypes */
377
378	BasicValue*
379	GetTblValue PARAMS ((v),
380	Value* v)
381	{
382	switch (v->basicValue->choiceId)
383	{
384	case BASICVALUE_INTEGER:
385	return v->basicValue;
386	default:
387	return NULL;
388	}
389	}
390
391	enum BasicTypeChoiceId
392	GetTblBasicType PARAMS ((bt),
393	BasicType* bt)
394	{
395	switch (bt->choiceId)
396	{
397	case BASICTYPE_LOCALTYPEREF:
398	case BASICTYPE_IMPORTTYPEREF:
399	return GetTblBasicType (bt->a.localTypeRef->link->type->basicType);
400	default:
401	return bt->choiceId;
402	}
403	}
404
405	TBLRange*
406	GenTblValueRange PARAMS ((tbl, m, tblMod, s, doSize),
407	TBL *tbl _AND_
408	Module *m _AND_
409	TBLModule *tblMod _AND_
410	Subtype *s _AND_
411	int doSize)
412	{
413	TBLRange* range;
414	BasicValue* from;
415	BasicValue* to;
416
417	if (tableFileVersionG<=1)
418	return NULL;
419
420	switch (s->choiceId)
421	{
422	case SUBTYPE_SINGLE:
423	switch (s->a.single->choiceId)
424	{
425	case SUBTYPEVALUE_SINGLEVALUE:
426	if (doSize)
427	return NULL;
428	from = to = GetTblValue (s->a.single->a.singleValue);
429	break;
430	case SUBTYPEVALUE_VALUERANGE:
431	if (doSize)
432	return NULL;
433	from =GetTblValue(s->a.single->a.valueRange->lowerEndValue);
434	to = GetTblValue (s->a.single->a.valueRange->upperEndValue);
435	break;
436	case SUBTYPEVALUE_SIZECONSTRAINT:
437	if (!doSize)
438	return NULL;
439	return GenTblValueRange (tbl, m, tblMod,
440	s->a.single->a.sizeConstraint, 0);
441	break;
442	default:
443	return NULL;
444	}
445	break;
446	case SUBTYPE_AND:
447	if (s->a.and && LIST_COUNT(s->a.and)==1)
448	return GenTblValueRange (tbl, m, tblMod,
449	FIRST_LIST_ELMT(s->a.and), doSize);
450	return NULL;
451	case SUBTYPE_OR:
452	if (s->a.and && LIST_COUNT(s->a.or)==1)
453	return GenTblValueRange (tbl, m, tblMod,
454	FIRST_LIST_ELMT(s->a.or), doSize);
455	return NULL;
456	case SUBTYPE_NOT:
457	return NULL;
458	}
459	if (!from \|\| !to)
460	return NULL;
461	range = MT (TBLRange);
462	range->from = from->a.integer;
463	range->to = to->a.integer;
464	return range;
465	}
466
467	TBLNamedNumberList*
468	GenTblValues PARAMS ((tbl, m, tblMod, list),
469	TBL *tbl _AND_
470	Module *m _AND_
471	TBLModule *tblMod _AND_
472	NamedNumberList* list)
473	{
474	TBLNamedNumberList* tnnl = NULL;
475
476	if (tableFileVersionG<=1)
477	return NULL;
478
479	if (list && !LIST_EMPTY(list))
480	{
481	ValueDef* vd;
482	tnnl = (TBLNamedNumberList) AsnListNew(sizeof(void));
483	FOR_EACH_LIST_ELMT(vd,list)
484	{
485	BasicValue* bv = GetTblValue(vd->value);
486	if (bv)
487	{
488	TBLNamedNumber* tnn = MT(TBLNamedNumber);
489	(TBLNamedNumber*)AsnListAppend(tnnl) = tnn;
490	tnn->value = bv->a.integer;
491	if (vd->definedName)
492	{
493	tnn->name.octetLen = strlen(vd->definedName);
494	tnn->name.octs = Malloc(tnn->name.octetLen+1);
495	strcpy(tnn->name.octs,vd->definedName);
496	tblStringsTotalG++;
497	tblStringLenTotalG += tnn->name.octetLen;
498	}
499	}
500	}
501
502	}
503	return tnnl;
504	}
505
506	TBLType*
507	GenTblTypesRec PARAMS ((tbl, m, tblMod, td, tblTd, t),
508	TBL *tbl _AND_
509	Module *m _AND_
510	TBLModule *tblMod _AND_
511	TypeDef *td _AND_
512	TBLTypeDef *tblTd _AND_
513	Type *t)
514	{
515	TBLType *tblT;
516	NamedType *e;
517	TBLType **tblTHndl;
518	Tag *tag;
519	TBLTag **tblTagHndl;
520
521	tblTypesTotalG++;
522	tblT = MT (TBLType);
523	tblT->content = MT (TBLTypeContent);
524	switch (t->basicType->choiceId)
525	{
526	case BASICTYPE_BOOLEAN:
527	tblT->typeId = TBL_BOOLEAN;
528	tblT->content->choiceId = TBLTYPECONTENT_PRIMTYPE;
529	break;
530
531	case BASICTYPE_INTEGER:
532	tblT->typeId = TBL_INTEGER;
533	tblT->content->choiceId = TBLTYPECONTENT_PRIMTYPE;
534	break;
535
536	case BASICTYPE_BITSTRING:
537	tblT->typeId = TBL_BITSTRING;
538	tblT->content->choiceId = TBLTYPECONTENT_PRIMTYPE;
539	tblT->values = GenTblValues(tbl,m,tblMod,t->basicType->a.bitString);
540	break;
541
542	case BASICTYPE_OCTETSTRING:
543	tblT->typeId = TBL_OCTETSTRING;
544	tblT->content->choiceId = TBLTYPECONTENT_PRIMTYPE;
545	if (t->subtypes)
546	tblT->constraint = GenTblValueRange(tbl, m, tblMod,t->subtypes,1);
547	break;
548
549	case BASICTYPE_NULL:
550	tblT->typeId = TBL_NULL;
551	tblT->content->choiceId = TBLTYPECONTENT_PRIMTYPE;
552	break;
553
554	case BASICTYPE_OID:
555	tblT->typeId = TBL_OID;
556	tblT->content->choiceId = TBLTYPECONTENT_PRIMTYPE;
557	break;
558
559	case BASICTYPE_REAL:
560	tblT->typeId = TBL_REAL;
561	tblT->content->choiceId = TBLTYPECONTENT_PRIMTYPE;
562	break;
563
564	case BASICTYPE_ENUMERATED:
565	tblT->typeId = TBL_ENUMERATED;
566	tblT->content->choiceId = TBLTYPECONTENT_PRIMTYPE;
567	tblT->values = GenTblValues(tbl,m,tblMod,t->basicType->a.enumerated);
568	break;
569
570	case BASICTYPE_SEQUENCE:
571	tblT->typeId = TBL_SEQUENCE;
572	tblT->content->choiceId = TBLTYPECONTENT_ELMTS;
573	tblT->content->a.elmts = AsnListNew (sizeof (void*));
574	FOR_EACH_LIST_ELMT (e, t->basicType->a.sequence)
575	{
576	tblTHndl = AsnListAppend (tblT->content->a.elmts);
577	*tblTHndl = GenTblTypesRec (tbl, m, tblMod, td, tblTd, e->type);
578
579	if (*tblTHndl == NULL)
580	break;
581
582	if (e->fieldName != NULL)
583	{
584	(**tblTHndl).fieldName.octetLen = strlen (e->fieldName);
585	(**tblTHndl).fieldName.octs =
586	Malloc ((**tblTHndl).fieldName.octetLen + 1);
587	strcpy ((**tblTHndl).fieldName.octs, e->fieldName);
588	tblStringsTotalG++;
589	tblStringLenTotalG += (**tblTHndl).fieldName.octetLen;
590	}
591
592	(**tblTHndl).optional =
593	((e->type->optional) \|\| (e->type->defaultVal != NULL));
594	}
595
596	break;
597
598	case BASICTYPE_SET:
599	tblT->typeId = TBL_SET;
600	tblT->content->choiceId = TBLTYPECONTENT_ELMTS;
601	tblT->content->a.elmts = AsnListNew (sizeof (void*));
602	FOR_EACH_LIST_ELMT (e, t->basicType->a.set)
603	{
604	tblTHndl = AsnListAppend (tblT->content->a.elmts);
605	*tblTHndl = GenTblTypesRec (tbl, m, tblMod, td, tblTd, e->type);
606
607	if (*tblTHndl == NULL)
608	break;
609
610	if (e->fieldName != NULL)
611	{
612	(**tblTHndl).fieldName.octetLen = strlen (e->fieldName);
613	(**tblTHndl).fieldName.octs =
614	Malloc ((**tblTHndl).fieldName.octetLen + 1);
615	strcpy ((**tblTHndl).fieldName.octs, e->fieldName);
616	tblStringsTotalG++;
617	tblStringLenTotalG += (**tblTHndl).fieldName.octetLen;
618	}
619
620	(**tblTHndl).optional =
621	((e->type->optional) \|\| (e->type->defaultVal != NULL));
622
623	}
624	break;
625
626	case BASICTYPE_SEQUENCEOF:
627	tblT->typeId = TBL_SEQUENCEOF;
628	tblT->content->choiceId = TBLTYPECONTENT_ELMTS;
629	tblT->content->a.elmts = AsnListNew (sizeof (void*));
630	tblTHndl = AsnListAppend (tblT->content->a.elmts);
631	*tblTHndl = GenTblTypesRec (tbl, m, tblMod, td, tblTd, t->basicType->a.sequenceOf);
632	if (t->subtypes)
633	tblT->constraint = GenTblValueRange(tbl, m, tblMod,t->subtypes,1);
634	break;
635
636	case BASICTYPE_SETOF:
637	tblT->typeId = TBL_SETOF;
638	tblT->content->choiceId = TBLTYPECONTENT_ELMTS;
639	tblT->content->a.elmts = AsnListNew (sizeof (void*));
640	tblTHndl = AsnListAppend (tblT->content->a.elmts);
641	*tblTHndl = GenTblTypesRec (tbl, m, tblMod, td, tblTd, t->basicType->a.setOf);
642	if (t->subtypes)
643	tblT->constraint = GenTblValueRange(tbl, m, tblMod,t->subtypes,1);
644	break;
645
646	case BASICTYPE_CHOICE:
647	tblT->typeId = TBL_CHOICE;
648	tblT->content->choiceId = TBLTYPECONTENT_ELMTS;
649	tblT->content->a.elmts = AsnListNew (sizeof (void*));
650	FOR_EACH_LIST_ELMT (e, t->basicType->a.set)
651	{
652	tblTHndl = AsnListAppend (tblT->content->a.elmts);
653	*tblTHndl = GenTblTypesRec (tbl, m, tblMod, td, tblTd, e->type);
654
655	if (*tblTHndl == NULL)
656	break;
657
658	if (e->fieldName != NULL)
659	{
660	(**tblTHndl).fieldName.octetLen = strlen (e->fieldName);
661	(**tblTHndl).fieldName.octs =
662	Malloc ((**tblTHndl).fieldName.octetLen + 1);
663	strcpy ((**tblTHndl).fieldName.octs, e->fieldName);
664	tblStringsTotalG++;
665	tblStringLenTotalG += (**tblTHndl).fieldName.octetLen;
666	}
667
668	(**tblTHndl).optional =
669	((e->type->optional) \|\| (e->type->defaultVal != NULL));
670
671	}
672	break;
673
674	case BASICTYPE_LOCALTYPEREF:
675	case BASICTYPE_IMPORTTYPEREF:
676	tblT->typeId = TBL_TYPEREF;
677	tblT->content->choiceId = TBLTYPECONTENT_TYPEREF;
678	tblT->content->a.typeRef = MT (TBLTypeRef);
679	tblT->content->a.typeRef->implicit = t->implicit;
680	tblT->content->a.typeRef->typeDef =
681	t->basicType->a.localTypeRef->link->tmpRefCount;
682	break;
683
684	default:
685	if (!abortTblTypeDefG) /* only print first time */
686	fprintf (stderr,"WARNING: Type definition \"%s\" will not be included in the type table because it contains a weird type.\n",td->definedName);
687	abortTblTypeDefG = TRUE;
688	Free (tblT->content);
689	Free (tblT);
690	tblT = NULL;
691	break;
692	}
693
694	/* handle constraints */
695	if (t->subtypes)
696	{
697	switch (GetTblBasicType(t->basicType))
698	{
699	case BASICTYPE_INTEGER:
700	tblT->constraint = GenTblValueRange(tbl,m,tblMod,t->subtypes,0);
701	break;
702	case BASICTYPE_OCTETSTRING:
703	case BASICTYPE_SEQUENCEOF:
704	tblT->constraint = GenTblValueRange(tbl,m,tblMod,t->subtypes,1);
705	break;
706	default:
707	break;
708	}
709	}
710
711	/* copy the tags */
712	if ((tblT != NULL) &&
713	((t->tags != NULL) && (!LIST_EMPTY (t->tags))))
714	{
715	tblT->tagList = AsnListNew (sizeof (void*));
716	FOR_EACH_LIST_ELMT (tag, t->tags)
717	{
718	tblTagsTotalG++;
719	tblTagHndl = AsnListAppend (tblT->tagList);
720	*tblTagHndl = MT (TBLTag);
721	switch (tag->tclass)
722	{
723	case UNIV:
724	(**tblTagHndl).tclass = UNIVERSAL;
725	break;
726	case APPL:
727	(**tblTagHndl).tclass = APPLICATION;
728	break;
729	case CNTX:
730	(**tblTagHndl).tclass = CONTEXT;
731	break;
732	case PRIV:
733	(**tblTagHndl).tclass = PRIVATE;
734	break;
735	}
736	(**tblTagHndl).code = tag->code;
737	}
738	}
739
740	return tblT;
741	} /* GenTblTypesRec */