types.c

asn.1 compiler

        case BASICTYPE_CHOICE:
           /*
            * must fill field names BEFORE filling choice elmts
            * (allows better naming for choice ids)
            */
            FillIDLFieldNames (r, t->basicType->a.choice);
            FillIDLChoiceElmts (r, m, td, t, t->basicType->a.choice);
            break;

        case BASICTYPE_SET:
        case BASICTYPE_SEQUENCE:
            FillIDLStructElmts (r, m, td, t, t->basicType->a.set);
            FillIDLFieldNames (r, t->basicType->a.set);
            break;

        case BASICTYPE_COMPONENTSOF:
        case BASICTYPE_SELECTION:
            fprintf (stderr, "Compiler error - COMPONENTS OF or SELECTION type slipped through normalizing phase.\n");
            break;

        case BASICTYPE_UNKNOWN:
        case BASICTYPE_MACRODEF:
        case BASICTYPE_MACROTYPE:
            /* do nothing */
            break;

    }

    /*
     * figure out whether this is a ptr based on the enclosing
     * type (if any) and optionality/default
     */
    idltri->isPtr = IsIDLPtr (r, td, parent, t);

    /* let user overide any defaults with the --snacc attributes */
    /* undefined for C++ ParseTypeRefAttribs (ctri, t->attrList); */


}  /* FillIDLTypeRefInfo */



static void
FillIDLStructElmts PARAMS ((r, m, td, parent, elmts),
    IDLRules *r _AND_
    Module *m _AND_
    TypeDef *td _AND_
    Type *parent _AND_
    NamedTypeList *elmts)
{
    NamedType *et;

    FOR_EACH_LIST_ELMT (et, elmts)
    {
        FillIDLTypeRefInfo (r, m, td, parent, et->type);
    }

}  /* FillIDLStructElmts */



/*
 *  Figures out non-conflicting enum names for the
 *  choice id's
 */
static void
FillIDLChoiceElmts PARAMS ((r, m, td, parent, elmts),
    IDLRules	*r _AND_
    Module	*m _AND_
    TypeDef	*td _AND_
    Type	*parent _AND_
    NamedTypeList *elmts)
{
    NamedType	*et;
    int		idCount = 0;
    IDLTRI	*idltri;
    int		len;

    /*
     * fill in type info for elmt types first
     */
    FOR_EACH_LIST_ELMT (et, elmts)
        FillIDLTypeRefInfo (r, m, td, parent, et->type);

    /*
     * set choiceId Symbol & value
     * eg
     *  Car ::= CHOICE {          enum CarChoice {
     *     chev ChevCar,              carChoice_chev,
     *     ford FordCar,              carChoice_ford,
     *     toyota ToyotaCar           carChoice_toyota
     *  }                         };
     *                            union Car switch (CarChoice) {
     *                                ChevCar *chev;
     *                                FordCar *ford;
     *                                ToyotaCar *toyota; };
     *                            };
     * NOTE that the union is anonymous
     */
    FOR_EACH_LIST_ELMT (et, elmts)
    {
        idltri =  et->type->idlTypeRefInfo;

        if (idltri == NULL)
            continue; /* wierd type */

        idltri->choiceIdValue = idCount++;

        len = strlen (td->idlTypeDefInfo->typeName) + strlen (idltri->fieldName);
        idltri->choiceIdSymbol = Malloc (len + 6 + 1);
        strcpy (idltri->choiceIdSymbol, td->idlTypeDefInfo->typeName);
	strcat (idltri->choiceIdSymbol, "Choice_");
        strcat (idltri->choiceIdSymbol, idltri->fieldName);

        if (r->capitalizeNamedElmts)
            Str2UCase (idltri->choiceIdSymbol, len);

	Str2LCase (idltri->choiceIdSymbol, 1);
    }

}  /* FillIDLChoiceElmts */


/*
 * takes a list of "sibling" (eg same level in a structure)
 * ElmtTypes and fills sets up the c field names in
 * the IDLTRI struct
 */
static void
FillIDLFieldNames PARAMS ((r, elmts),
    IDLRules *r _AND_
    NamedTypeList *elmts)
{
    NamedType  *et;
    IDLTRI *idltri;
    DefinedObj *fieldNames;
    int        len, num, digit, i, tmpLen;
    char      *tmpName;
    char      *asn1FieldName;
    char      *cFieldName;

    /*
     * Initialize fieldname data
     * allocate (if nec) and fill in CTRI fieldname if poss
     * from asn1 field name.  leave blank otherwise
     */
    fieldNames = NewObjList();
    FOR_EACH_LIST_ELMT (et, elmts)
    {
        idltri =  et->type->idlTypeRefInfo;
        if (idltri == NULL)
        {
            idltri = MT (IDLTRI);
            et->type->idlTypeRefInfo = idltri;
        }
        if (et->fieldName != NULL)
        {
            /*
             * can assume that the field names are
             * distinct because they have passed the
             * error checking step.
             * However, still call MakeCxxStrUnique
             * to change any field names that
             * conflict with C++ keywords
             */
            asn1FieldName = et->fieldName;
            tmpName = Asn1FieldName2CFieldName (asn1FieldName);
            idltri->fieldName = Malloc (strlen (tmpName) + 1 + r->maxDigitsToAppend);
            strcpy (idltri->fieldName, tmpName);
            Free (tmpName);

/*   old    idltri->fieldName = Asn1FieldName2CFieldName (asn1FieldName); */

            MakeCxxStrUnique (fieldNames, idltri->fieldName, r->maxDigitsToAppend, 1);
            DefineObj (&fieldNames, idltri->fieldName);
        }
    }


    FOR_EACH_LIST_ELMT (et, elmts)
    {
        idltri =  et->type->idlTypeRefInfo;

        /*
         * generate field names for those without them
         */
        if (idltri->fieldName == NULL)
        {
            if ((et->type->basicType->choiceId == BASICTYPE_LOCALTYPEREF) ||
                 (et->type->basicType->choiceId == BASICTYPE_IMPORTTYPEREF))
            {
                /*
                 * take ref'd type name as field name
                 * convert first let to lower case
                 */
                tmpName = et->type->basicType->a.localTypeRef->link->idlTypeDefInfo->typeName;
                tmpName =  Asn1TypeName2CTypeName (tmpName);
                cFieldName = Malloc (strlen (tmpName) + r->maxDigitsToAppend +1);
                strcpy (cFieldName, tmpName);
                Free (tmpName);
                if (isupper (cFieldName[0]))
                    cFieldName[0] = tolower (cFieldName[0]);
            }
            else
            {
                /*
                 * get default field name for this type
                 */
                tmpName = r->typeConvTbl[et->type->basicType->choiceId].defaultFieldName;
                cFieldName = Malloc (strlen (tmpName) + r->maxDigitsToAppend +1);
                strcpy (cFieldName, tmpName);

                if (isupper (cFieldName[0]))
                    cFieldName[0] = tolower (cFieldName[0]);
            }


            len = strlen (cFieldName);

            /*
             * try to use just the type name (with lower case first char).
             * if that is already used in this type or a C++ keyword,
             * append ascii digits to field name until unique
             * in this type
             */
            MakeCxxStrUnique (fieldNames, cFieldName, r->maxDigitsToAppend, 1);
            DefineObj (&fieldNames, cFieldName);
            idltri->fieldName = cFieldName;
        }
    }
    FreeDefinedObjs (&fieldNames);
}  /* FillIDLFieldNames */



/*
 * returns true if this c type for this type should be
 * be ref'd as a ptr
 */
static int
IsIDLPtr PARAMS ((r, td, parent, t),
    IDLRules *r _AND_
    TypeDef *td _AND_
    Type *parent _AND_
    Type *t)
{
    IDLTDI *idltdi;
    int retVal = FALSE;

    /*
     * inherit ptr attriubutes from ref'd type if any
     * otherwise grab lib c type def from the IDLRules
     */
    if ((t->basicType->choiceId == BASICTYPE_LOCALTYPEREF) ||
        (t->basicType->choiceId == BASICTYPE_IMPORTTYPEREF))
    {
        idltdi = t->basicType->a.localTypeRef->link->idlTypeDefInfo;
    }
    else
        idltdi = &r->typeConvTbl[GetBuiltinType (t)];

    /* no parent means t is the root of a typedef */
    if ((parent == NULL) && (idltdi->isPtrForTypeDef))
        retVal = TRUE;

    else if ((parent != NULL) &&
             ((parent->basicType->choiceId == BASICTYPE_SET) ||
             (parent->basicType->choiceId == BASICTYPE_SEQUENCE)) &&
             (idltdi->isPtrInSetAndSeq))
        retVal = TRUE;

    else if ((parent != NULL) &&
             ((parent->basicType->choiceId == BASICTYPE_SETOF) ||
             (parent->basicType->choiceId == BASICTYPE_SEQUENCEOF)) &&
             (idltdi->isPtrInList))
        retVal = TRUE;

    else if ((parent != NULL) &&
             (parent->basicType->choiceId == BASICTYPE_CHOICE) &&
             (idltdi->isPtrInChoice))
        retVal = TRUE;

    else if (((t->optional) || (t->defaultVal != NULL)) && (idltdi->isPtrForOpt))
        retVal = TRUE;

    return retVal;
}  /* IsIDLPtr */



/* fill given idltdi with defaults from table for given typedef */
void
FillIDLTDIDefaults PARAMS ((r, idltdi, td),
    IDLRules *r _AND_
    IDLTDI *idltdi _AND_
    TypeDef *td)
{
    IDLTDI *tblidltdi;
    int typeIndex;
    char *tmpName;

    typeIndex = GetBuiltinType (td->type);

    if (typeIndex < 0)
        return;

    tblidltdi = &r->typeConvTbl[typeIndex];

    memcpy (idltdi, tblidltdi, sizeof (IDLTDI));

    /* make sure class name is unique wrt to previously defined classes */
    tmpName = Asn1TypeName2CTypeName (td->definedName);
    idltdi->typeName = Malloc (strlen (tmpName) + 2 + r->maxDigitsToAppend +1);
    strcpy (idltdi->typeName, tmpName);
    if (tblidltdi->asn1TypeId != BASICTYPE_CHOICE)
	strcat (idltdi->typeName, "_T");
    Free (tmpName);

    MakeCxxStrUnique (definedNamesG, idltdi->typeName, r->maxDigitsToAppend, 1);
    DefineObj (&definedNamesG, idltdi->typeName);

} /* FillIDLTDIDefaults */