/* * compiler/core/link.c * * first links value refs in the import list then * links value references in value defs and types' default values * * * Mike Sample * 91/09/04 * Completely Rewritten for new ModuleList data structure (ASN.1 based) * * Copyright (C) 1991, 1992 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/Darwin/Security/SecuritySNACCRuntime/compiler/core/link-values.c,v 1.1 2001/06/20 21:27:57 dmitch Exp $ * $Log: link-values.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:49 aram * Originals from SMIME Free Library. * * Revision 1.3 1995/07/25 19:41:38 rj * changed `_' to `-' in file names. * * Revision 1.2 1994/09/01 00:38:43 rj * snacc_config.h removed. * * Revision 1.1 1994/08/28 09:49:19 rj * first check-in. for a list of changes to the snacc-1.1 distribution please refer to the ChangeLog. * */ #include #include #include "asn-incl.h" #include "asn1module.h" #include "mem.h" #include "snacc-util.h" #include "link-values.h" extern Module *usefulTypeModG; /* non-exported fcn prototypes */ void ValueLinkImportLists PROTO ((ModuleList *m)); void ValueLinkTypeDef PROTO ((ModuleList *m, Module *currMod, TypeDef *head)); void ValueLinkElmtTypes PROTO ((ModuleList *m, Module *currMod, TypeDef *head, NamedTypeList *e)); void ValueLinkElmtType PROTO ((ModuleList *m, Module *currMod, TypeDef *head, NamedType *n)); void ValueLinkType PROTO ((ModuleList *m, Module *currMod, TypeDef *head, Type *currType)); void ValueLinkBasicType PROTO ((ModuleList *m, Module *currMod, TypeDef *head, Type *type, BasicType *bt)); void ValueLinkSubtypes PROTO ((ModuleList *m, Module *currMod, TypeDef *head, Type *currType, Subtype *s)); void ValueLinkSubtypeValue PROTO ((ModuleList *m, Module *currMod, TypeDef *head, Type *currType, SubtypeValue *s)); void ValueLinkNamedElmts PROTO ((ModuleList *m, Module *currMod, TypeDef *head, Type *t, ValueDefList *v)); void ValueLinkValueDef PROTO ((ModuleList *m, Module *currMod, ValueDef *v)); void ValueLinkValue PROTO ((ModuleList *m, Module *currMod, ValueDef *head, Type *valuesType, Value *v)); void ValueLinkBasicValue PROTO ((ModuleList *m, Module *currMod, ValueDef *head, Type *valuesType, Value *v, BasicValue *bv)); void ValueLinkOid PROTO ((ModuleList *m, Module *currMod, ValueDef *head, Value *v, OID *oid)); void ValueLinkRosOperationMacroType PROTO ((ModuleList *m, Module *currMod, TypeDef *head, Type *t, BasicType *bt, RosOperationMacroType *op)); void ValueLinkRosErrorMacroType PROTO ((ModuleList *m, Module *currMod, TypeDef *head, Type *t, BasicType *bt, RosErrorMacroType *err)); void ValueLinkRosBindMacroType PROTO ((ModuleList *m, Module *currMod, TypeDef *head, Type *t, BasicType *bt, RosBindMacroType *bind)); void ValueLinkRosAseMacroType PROTO ((ModuleList *m, Module *currMod, TypeDef *head, Type *t, BasicType *bt, RosAseMacroType *ase)); void ValueLinkRosAcMacroType PROTO ((ModuleList *m, Module *currMod, TypeDef *head, Type *t, BasicType *bt, RosAcMacroType *ac)); void ValueLinkMtsasExtensionsMacroType PROTO ((ModuleList *m, Module *currMod, TypeDef *head, Type *t, BasicType *bt, MtsasExtensionsMacroType *exts)); void ValueLinkMtsasExtensionMacroType PROTO ((ModuleList *m, Module *currMod, TypeDef *head, Type *t, BasicType *bt, MtsasExtensionMacroType *ext)); void ValueLinkMtsasExtensionAttributeMacroType PROTO ((ModuleList *m, Module *currMod, TypeDef *head, Type *t, BasicType *bt, MtsasExtensionAttributeMacroType *ext)); void ValueLinkMtsasTokenMacroType PROTO ((ModuleList *m, Module *currMod, TypeDef *head, Type *t, BasicType *bt, MtsasTokenMacroType *tok)); void ValueLinkMtsasTokenDataMacroType PROTO ((ModuleList *m, Module *currMod, TypeDef *head, Type *t, BasicType *bt, MtsasTokenDataMacroType *tok)); void ValueLinkMtsasSecurityCategoryMacroType PROTO ((ModuleList *m, Module *currMod, TypeDef *head, Type *t, BasicType *bt, MtsasSecurityCategoryMacroType *sec)); void ValueLinkAsnObjectMacroType PROTO ((ModuleList *m, Module *currMod, TypeDef *head, Type *t, BasicType *bt, AsnObjectMacroType *obj)); void ValueLinkAsnPortMacroType PROTO ((ModuleList *m, Module *currMod, TypeDef *head, Type *t, BasicType *bt, AsnPortMacroType *p)); void ValueLinkAsnAbstractBindMacroType PROTO ((ModuleList *m, Module *currMod, TypeDef *head, Type *t, BasicType *bt, AsnAbstractBindMacroType *bind)); void ValueLinkSnmpObjectTypeMacroType PROTO ((ModuleList *m, Module *currMod, TypeDef *head, Type *t, BasicType *bt, SnmpObjectTypeMacroType *ot)); /* end of prototypes */ static char *asn1SrcFileNameG; static int linkOidCallDepthG = 0; /* big hack!! */ /* * returns 0 if no link error occured * otherwise returns a value < 0. * processing should not continue is an error is returned */ int LinkValueRefs PARAMS ((m), ModuleList *m) { Module *currMod; TypeDef *td; ValueDef *vd; int linkErr = 0; /* * link imported types/values to there definition if * the defining module is in the modulelist */ ValueLinkImportLists (m); /* link useful module, in case there are value defs there */ if (usefulTypeModG != NULL) { currMod = usefulTypeModG; asn1SrcFileNameG = currMod->asn1SrcFileName; /* * link this modules object identifier value */ ValueLinkOid (m, currMod, NULL, NULL, currMod->modId->oid); /* * go through each type in typeList and link as nec */ FOR_EACH_LIST_ELMT (td, currMod->typeDefs) { ValueLinkTypeDef (m, currMod, td); } /* * go through each value in valueList and link as nec */ FOR_EACH_LIST_ELMT (vd, currMod->valueDefs) { ValueLinkValueDef (m, currMod, vd); } if (currMod->status != MOD_ERROR) currMod->status = MOD_OK; else linkErr = -1; } /* * go through types, values & macros of each parsed module */ FOR_EACH_LIST_ELMT (currMod, m) { asn1SrcFileNameG = currMod->asn1SrcFileName; /* * link this modules object identifier value */ ValueLinkOid (m, currMod, NULL, NULL, currMod->modId->oid); /* * go through each type in typeList and link as nec */ FOR_EACH_LIST_ELMT (td, currMod->typeDefs) { ValueLinkTypeDef (m, currMod, td); } /* * go through each value in valueList and link as nec */ FOR_EACH_LIST_ELMT (vd, currMod->valueDefs) { ValueLinkValueDef (m, currMod, vd); } if (currMod->status != MOD_ERROR) currMod->status = MOD_OK; else linkErr = -1; } return linkErr; } /* ValueLinkRefs */ /* * go through each modules import lists and link * any values as nec. values'symbols start with a * lowercase letter */ void ValueLinkImportLists PARAMS ((m), ModuleList *m) { Module *currMod; TypeDef *t; ValueDef *v; ImportModule *currImpList; ImportElmt *currImpElmt; Module *impRefMod; /* link imports of each module in the list */ FOR_EACH_LIST_ELMT (currMod, m) { /* for each import list in the current module */ FOR_EACH_LIST_ELMT (currImpList, currMod->imports) { /* see if the referenced module is in the list */ impRefMod = LookupModule (m, currImpList->modId->name, currImpList->modId->oid); if (impRefMod == NULL) { /* the type linker will have reported this error */ continue; } /* * link each value referencing import elmt in * the current import list */ FOR_EACH_LIST_ELMT (currImpElmt, currImpList->importElmts) { /* * only link values (all vals have lowercase first letter) */ if (!islower (currImpElmt->name[0])) continue; v = LookupValue (impRefMod->valueDefs, currImpElmt->name); if (v != NULL) { if (!v->exported) { currMod->status = MOD_ERROR; PrintErrLoc (currMod->asn1SrcFileName, currImpElmt->lineNo); fprintf (stderr,"ERROR - \"%s\" module imports value \"%s\", which is not exported from module \"%s\".\n", currMod->modId->name, currImpElmt->name, impRefMod->modId->name); } /* resolve value */ currImpElmt->resolvedRef = (ImportElmtChoice*)Malloc (sizeof (ImportElmtChoice)); currImpElmt->resolvedRef->choiceId = IMPORTELMTCHOICE_VALUE; currImpElmt->resolvedRef->a.value = v; } else /* value not found in ref'd module */ { currMod->status = MOD_ERROR; PrintErrLoc (currMod->asn1SrcFileName, currImpElmt->lineNo); fprintf (stderr,"ERROR - \"%s\" is imported from module \"%s\" by module \"%s\", but is not defined in the referenced module\n", currImpElmt->name, impRefMod->modId->name, currMod->modId->name); } } } } } /* ValueLinkImportLists */ void ValueLinkTypeDef PARAMS ((m, currMod, head), ModuleList *m _AND_ Module *currMod _AND_ TypeDef *head) { if (head == NULL) return; ValueLinkType (m, currMod, head, head->type); } /* ValueLinkTypeDef */ void ValueLinkType PARAMS ((m, currMod, head, t), ModuleList *m _AND_ Module *currMod _AND_ TypeDef *head _AND_ Type *t) { if (t == NULL) return; ValueLinkBasicType (m, currMod, head, t, t->basicType); ValueLinkSubtypes (m, currMod, head, t, t->subtypes); if (t->defaultVal != NULL) ValueLinkValue (m, currMod, NULL, t, t->defaultVal->value); } /* ValueLinkType */ void ValueLinkElmtTypes PARAMS ((m, currMod, head, e), ModuleList *m _AND_ Module *currMod _AND_ TypeDef *head _AND_ NamedTypeList *e) { NamedType *n; FOR_EACH_LIST_ELMT (n, e) { ValueLinkElmtType (m, currMod, head, n); } } /* ValueLinkElmtTypes */ void ValueLinkElmtType PARAMS ((m, currMod, head, n), ModuleList *m _AND_ Module *currMod _AND_ TypeDef *head _AND_ NamedType *n) { if (n != NULL) ValueLinkType (m, currMod, head, n->type); } void ValueLinkBasicType PARAMS ((m, currMod, head, type, bt), ModuleList *m _AND_ Module *currMod _AND_ TypeDef *head _AND_ Type *type _AND_ BasicType *bt) { TypeDef *tmpTypeDef; TypeDefList *tmpTypeDefs; Type *tmpType; Module *tmpMod; NamedType *tmpElmtType; ImportElmt *impElmt; ImportModule *impMod; int implicitRef; if (bt == NULL) return; switch (bt->choiceId) { case BASICTYPE_SEQUENCE: case BASICTYPE_SET: case BASICTYPE_CHOICE: ValueLinkElmtTypes (m, currMod, head, bt->a.set); break; case BASICTYPE_SEQUENCEOF: case BASICTYPE_SETOF: ValueLinkType (m, currMod, head, bt->a.setOf); break; case BASICTYPE_SELECTION: case BASICTYPE_COMPONENTSOF: case BASICTYPE_ANYDEFINEDBY: case BASICTYPE_LOCALTYPEREF: case BASICTYPE_IMPORTTYPEREF: break; /* * these types may optionally have named elmts */ case BASICTYPE_INTEGER: case BASICTYPE_BITSTRING: case BASICTYPE_ENUMERATED: ValueLinkNamedElmts (m, currMod, head, type, bt->a.integer); break; /* * these types have no extra info and cause no linking action */ case BASICTYPE_UNKNOWN: case BASICTYPE_BOOLEAN: case BASICTYPE_OCTETSTRING: case BASICTYPE_NULL: case BASICTYPE_OID: case BASICTYPE_REAL: case BASICTYPE_ANY: case BASICTYPE_MACRODEF: /* * these have no more info - only the choiceId is used */ break; case BASICTYPE_MACROTYPE: switch (bt->a.macroType->choiceId) { case MACROTYPE_ROSOPERATION: case MACROTYPE_ASNABSTRACTOPERATION: ValueLinkRosOperationMacroType (m, currMod, head, type, bt, bt->a.macroType->a.rosOperation); break; case MACROTYPE_ROSERROR: case MACROTYPE_ASNABSTRACTERROR: ValueLinkRosErrorMacroType (m, currMod, head, type, bt, bt->a.macroType->a.rosError); break; case MACROTYPE_ROSBIND: case MACROTYPE_ROSUNBIND: ValueLinkRosBindMacroType (m, currMod, head, type, bt, bt->a.macroType->a.rosBind); break; case MACROTYPE_ROSASE: ValueLinkRosAseMacroType (m, currMod, head, type, bt, bt->a.macroType->a.rosAse); break; case MACROTYPE_MTSASEXTENSIONS: ValueLinkMtsasExtensionsMacroType (m, currMod, head, type, bt, bt->a.macroType->a.mtsasExtensions); break; case MACROTYPE_MTSASEXTENSION: ValueLinkMtsasExtensionMacroType (m, currMod, head, type, bt, bt->a.macroType->a.mtsasExtension); break; case MACROTYPE_MTSASEXTENSIONATTRIBUTE: ValueLinkMtsasExtensionAttributeMacroType (m, currMod, head, type, bt, bt->a.macroType->a.mtsasExtensionAttribute); break; case MACROTYPE_MTSASTOKEN: ValueLinkMtsasTokenMacroType (m, currMod, head, type, bt, bt->a.macroType->a.mtsasToken); break; case MACROTYPE_MTSASTOKENDATA: ValueLinkMtsasTokenDataMacroType (m, currMod, head, type, bt, bt->a.macroType->a.mtsasTokenData); break; case MACROTYPE_MTSASSECURITYCATEGORY: ValueLinkMtsasSecurityCategoryMacroType (m, currMod, head, type, bt, bt->a.macroType->a.mtsasSecurityCategory); break; case MACROTYPE_ASNOBJECT: ValueLinkAsnObjectMacroType (m, currMod, head, type, bt, bt->a.macroType->a.asnObject); break; case MACROTYPE_ASNPORT: ValueLinkAsnPortMacroType (m, currMod, head, type, bt, bt->a.macroType->a.asnPort); break; case MACROTYPE_ASNABSTRACTBIND: case MACROTYPE_ASNABSTRACTUNBIND: ValueLinkAsnAbstractBindMacroType (m, currMod, head, type, bt, bt->a.macroType->a.asnAbstractBind); break; case MACROTYPE_AFALGORITHM: case MACROTYPE_AFENCRYPTED: case MACROTYPE_AFPROTECTED: case MACROTYPE_AFSIGNATURE: case MACROTYPE_AFSIGNED: ValueLinkType (m, currMod, head, bt->a.macroType->a.afAlgorithm); break; case MACROTYPE_SNMPOBJECTTYPE: ValueLinkSnmpObjectTypeMacroType (m, currMod, head, type, bt, bt->a.macroType->a.snmpObjectType); break; default: fprintf (stderr, "ValueLinkBasicType: ERROR - unknown macro type id!\n"); break; } break; default: fprintf (stderr, "ValueLinkBasicType: ERROR - unknown basic type id!\n"); } } /* ValueLinkBasicType */ /* * resolve any type/value refs in the subtypes (if any) */ void ValueLinkSubtypes PARAMS ((m, currMod, head, currType, s), ModuleList *m _AND_ Module *currMod _AND_ TypeDef *head _AND_ Type *currType _AND_ Subtype *s) { Subtype *sElmt; if (s == NULL) return; switch (s->choiceId) { case SUBTYPE_SINGLE: ValueLinkSubtypeValue (m, currMod, head, currType, s->a.single); break; case SUBTYPE_AND: case SUBTYPE_OR: case SUBTYPE_NOT: FOR_EACH_LIST_ELMT (sElmt, s->a.and) { ValueLinkSubtypes (m, currMod, head, currType, sElmt); } break; default: fprintf (stderr, "ValueLinkSubtypes: ERROR - unknown Subtype id\n"); break; } } /* ValueLinkSubtypes */ void ValueLinkSubtypeValue PARAMS ((m, currMod, head, currType, s), ModuleList *m _AND_ Module *currMod _AND_ TypeDef *head _AND_ Type *currType _AND_ SubtypeValue *s) { Constraint *constraint; if (s == NULL) return; switch (s->choiceId) { case SUBTYPEVALUE_SINGLEVALUE: ValueLinkValue (m, currMod, NULL, currType, s->a.singleValue); break; case SUBTYPEVALUE_CONTAINED: ValueLinkType (m, currMod, head, s->a.contained); break; case SUBTYPEVALUE_VALUERANGE: ValueLinkValue (m, currMod, NULL, currType, s->a.valueRange->lowerEndValue); ValueLinkValue (m, currMod, NULL, currType, s->a.valueRange->upperEndValue); break; case SUBTYPEVALUE_PERMITTEDALPHABET: ValueLinkSubtypes (m, currMod, head, currType, s->a.permittedAlphabet); break; case SUBTYPEVALUE_SIZECONSTRAINT: ValueLinkSubtypes (m, currMod, head, currType, s->a.sizeConstraint); break; case SUBTYPEVALUE_INNERSUBTYPE: FOR_EACH_LIST_ELMT (constraint, s->a.innerSubtype->constraints) { ValueLinkSubtypes (m, currMod, head, currType, constraint->valueConstraints); } break; default: fprintf (stderr,"ValueLinkSubtype: ERROR - unknown subtype choiceId\n"); } } /* ValueLinkSubtype */ void ValueLinkNamedElmts PARAMS ((m, currMod, head, t, v), ModuleList *m _AND_ Module *currMod _AND_ TypeDef *head _AND_ Type *t _AND_ ValueDefList *v) { ValueDef *vd; FOR_EACH_LIST_ELMT (vd, v) { ValueLinkValue (m, currMod, vd, vd->value->type, vd->value); } } /* ValueLinkNamedElmts */ void ValueLinkValueDef PARAMS ((m, currMod, v), ModuleList *m _AND_ Module *currMod _AND_ ValueDef *v) { if (v == NULL) return; ValueLinkType (m, currMod, NULL, v->value->type); ValueLinkValue (m, currMod, v, v->value->type, v->value); } /* ValueLinkValueDef */ void ValueLinkValue PARAMS ((m, currMod, head, valuesType, v), ModuleList *m _AND_ Module *currMod _AND_ ValueDef *head _AND_ Type *valuesType _AND_ Value *v) { if (v == NULL) return; ValueLinkBasicValue (m, currMod, head, valuesType, v, v->basicValue); } /* ValueLinkValue */ void ValueLinkBasicValue PARAMS ((m, currMod, head, valuesType, v, bv), ModuleList *m _AND_ Module *currMod _AND_ ValueDef *head _AND_ Type *valuesType _AND_ Value *v _AND_ BasicValue *bv) { ValueDef *tmpValueDef; Module *tmpMod; ImportElmt *impElmt; ImportModule *impMod; ValueDef *n; ValueDefList *namedElmtList; if (v == NULL) return; switch (bv->choiceId) { case BASICVALUE_UNKNOWN: case BASICVALUE_EMPTY: case BASICVALUE_INTEGER: case BASICVALUE_SPECIALINTEGER: case BASICVALUE_BOOLEAN: case BASICVALUE_REAL: case BASICVALUE_SPECIALREAL: case BASICVALUE_ASCIITEXT: case BASICVALUE_ASCIIHEX: case BASICVALUE_ASCIIBITSTRING: case BASICVALUE_BERVALUE: case BASICVALUE_PERVALUE: case BASICVALUE_NAMEDVALUE: case BASICVALUE_NULL: case BASICVALUE_VALUENOTATION: case BASICVALUE_OID: break; case BASICVALUE_LOCALVALUEREF: /* * parser sets all value refs to "Local" so must * check if local, then if import .... */ /* * first check in named elmts of the given type */ namedElmtList = GetAllNamedElmts (valuesType); if (namedElmtList != NULL) { n = LookupValue (namedElmtList, bv->a.localValueRef->valueName); if (n != NULL) { bv->a.localValueRef->link = n; bv->a.localValueRef->module = currMod; /* now free list structure (not data elmts) */ AsnListFree (namedElmtList); break; /* exit switch since done here. */ } } /* * second, look for values defined in this module */ tmpValueDef = LookupValue (currMod->valueDefs, bv->a.localValueRef->valueName); if (tmpValueDef != NULL) { bv->a.localValueRef->link = tmpValueDef; break; /* exit switch since done here. */ } else bv->choiceId = BASICVALUE_IMPORTVALUEREF; /*!!!!!!!!!! fall through from else clause */ case BASICVALUE_IMPORTVALUEREF: /* This handles "modname.value" value refs. */ if (bv->a.importValueRef->moduleName != NULL) { /* * Lookup the import list maintained in this module * from the named module. (the parser generates * an import list from Foo module for "Foo.Bar" style * import refs) */ impMod = LookupImportModule (currMod, bv->a.importValueRef->moduleName); if (impMod == NULL) /* whoa, compiler error */ { currMod->status = MOD_ERROR; fprintf (stderr,"Compiler Error: \"%s.%s\" valueref - no import list defined from module \"%s\".\n", bv->a.importValueRef->moduleName, bv->a.importValueRef->valueName, bv->a.importValueRef->moduleName); return; } impElmt = LookupImportElmtInImportElmtList (impMod->importElmts, bv->a.importValueRef->valueName); if (impElmt == NULL) /* whoa, compiler error again */ { currMod->status = MOD_ERROR; fprintf (stderr,"Compiler Error: \"%s.%s\" valueref - no import element defined for value \"%s\".\n", bv->a.importValueRef->moduleName, bv->a.importValueRef->valueName, bv->a.importValueRef->valueName); } else if (impElmt->resolvedRef != NULL) { if (impElmt->resolvedRef->choiceId != IMPORTELMTCHOICE_VALUE) fprintf (stderr,"Linker Warning: import VALUE ref \"%s\" resolves with an imported TYPE\n", impElmt->name); bv->a.importValueRef->link = impElmt->resolvedRef->a.value; bv->a.importValueRef->module = impMod->moduleRef; } else { PrintErrLoc (currMod->asn1SrcFileName, v->lineNo); fprintf (stderr,"reference to unresolved imported value \"%s\"\n", impElmt->name); } } else { impElmt = LookupImportElmtInModule (currMod, bv->a.importValueRef->valueName, &impMod); if ((impElmt != NULL) && (!impElmt->privateScope)) { /* * if import elmt is resolved then * set up link */ if (impElmt->resolvedRef != NULL) { if (impElmt->resolvedRef->choiceId != IMPORTELMTCHOICE_VALUE) fprintf (stderr,"Linker Warning: import VALUE ref \"%s\" resolves with an imported TYPE\n", impElmt->name); bv->a.importValueRef->link = impElmt->resolvedRef->a.value; bv->a.importValueRef->module = impMod->moduleRef; } else { PrintErrLoc (currMod->asn1SrcFileName, v->lineNo); fprintf (stderr,"reference to unresolved imported value \"%s\"\n", impElmt->name); } } /* * third, look for values defined in the useful module */ else if ((usefulTypeModG != NULL) && ((tmpValueDef = LookupValue (usefulTypeModG->valueDefs, bv->a.localValueRef->valueName)) != NULL)) { bv->a.localValueRef->link = tmpValueDef; bv->a.localValueRef->module = usefulTypeModG; } else { /* * value not defined locally, nor imported nor * defined in useful types module */ currMod->status = MOD_ERROR; PrintErrLoc (currMod->asn1SrcFileName, v->lineNo); fprintf (stderr,"ERROR - value \"%s\" is referenced but not defined or imported.\n", bv->a.importValueRef->valueName); } } break; case BASICVALUE_LINKEDOID: ValueLinkOid (m, currMod, head, v, bv->a.linkedOid); break; default: fprintf (stderr,"ValueLinkBasicValue: ERROR - unknown value type\n"); } } /* ValueLinkBasicValue */ /* * link the value refs from an object identifier * * * eg * for { ccitt foo (1) bar bell (bunt) 2 } the format is * * ccitt * arcnum is set to number from oid table (oid.c) * foo (1) * - arc num is set to 1 * - sets up a new value def foo defined as 1 * - makes oid valueref a value ref to foo (doesn't link it tho) * bar * - makes oid valueref a value ref to bar (doesn't link it tho) * bell (bunt) * - sets up a new value def bell defined as a val ref to bunt * - makes oid valueref a value ref to bell (doesn't link it tho) * 2 * -arc num is set to 2 * */ void ValueLinkOid PARAMS ((m, currMod, head, v, oid), ModuleList *m _AND_ Module *currMod _AND_ ValueDef *head _AND_ Value *v _AND_ OID *oid) { ValueDef *tmpValueDef; ImportElmt *impElmt; ImportModule *impMod; int lineNo; OID *firstElmt; Value *val; /* * WARNING: for cyclic oid value definintions like. * foo OID ::= { bar 1 3 } * bar OID ::= { foo 1 3 } * infinite recursion is prevented by * a hack (linkOidCallDepth) */ if (linkOidCallDepthG > 100) { currMod->status = MOD_ERROR; PrintErrLoc (currMod->asn1SrcFileName, v->lineNo); fprintf (stderr,"ERROR - OBJECT IDENTIFIER value \"%s\" appears to be defined recursively\n", head->definedName); linkOidCallDepthG = 0; return; } else linkOidCallDepthG++; for (firstElmt = oid; oid != NULL; oid = oid->next) { if (oid->valueRef != NULL) { ValueLinkValue (m, currMod, head, NULL, oid->valueRef); if ((oid->valueRef->basicValue->choiceId != BASICVALUE_LOCALVALUEREF) && (oid->valueRef->basicValue->choiceId != BASICVALUE_IMPORTVALUEREF)) { fprintf (stderr,"Internal error: Oid valueref is not a ref\n"); break; /* exit for */ } /* * leave simplification (replacement of value refs with values) * of oid values to normalize.c */ } } linkOidCallDepthG--; } /* ValueLinkOid */ void ValueLinkRosOperationMacroType PARAMS ((m, currMod, head, t, bt, op), ModuleList *m _AND_ Module *currMod _AND_ TypeDef *head _AND_ Type *t _AND_ BasicType *bt _AND_ RosOperationMacroType *op) { TypeOrValue *tOrV; if (op->arguments != NULL) ValueLinkType (m, currMod, head, op->arguments->type); if (op->result != NULL) ValueLinkType (m, currMod, head, op->result->type); /* * go through errors (if any) and link types/values */ FOR_EACH_LIST_ELMT (tOrV, op->errors) { if (tOrV->choiceId == TYPEORVALUE_TYPE) ValueLinkType (m, currMod, head, tOrV->a.type); else ValueLinkValue (m, currMod, NULL, t, tOrV->a.value); } /* * go through linked operations (if any) and * link types/values */ FOR_EACH_LIST_ELMT (tOrV, op->linkedOps) { if (tOrV->choiceId == TYPEORVALUE_TYPE) ValueLinkType (m, currMod, head, tOrV->a.type); else ValueLinkValue (m, currMod, NULL, t, tOrV->a.value); } } /* ValueLinkRosOperationMacroType */ void ValueLinkRosErrorMacroType PARAMS ((m, currMod, head, t, bt, err), ModuleList *m _AND_ Module *currMod _AND_ TypeDef *head _AND_ Type *t _AND_ BasicType *bt _AND_ RosErrorMacroType *err) { if ((err != NULL) && (err->parameter != NULL)) { ValueLinkType (m, currMod, head, err->parameter->type); } } /* ValueLinkRosErrorMacroType */ void ValueLinkRosBindMacroType PARAMS ((m, currMod, head, t, bt, bind), ModuleList *m _AND_ Module *currMod _AND_ TypeDef *head _AND_ Type *t _AND_ BasicType *bt _AND_ RosBindMacroType *bind) { if (bind != NULL) { ValueLinkElmtType (m, currMod, head, bind->argument); ValueLinkElmtType (m, currMod, head, bind->result); ValueLinkElmtType (m, currMod, head, bind->error); } } /* ValueLinkRosBindMacroType */ void ValueLinkRosAseMacroType PARAMS ((m, currMod, head, t, bt, ase), ModuleList *m _AND_ Module *currMod _AND_ TypeDef *head _AND_ Type *t _AND_ BasicType *bt _AND_ RosAseMacroType *ase) { Value *v; FOR_EACH_LIST_ELMT (v, ase->operations) ValueLinkValue (m, currMod, NULL, t, v); FOR_EACH_LIST_ELMT (v, ase->consumerInvokes) ValueLinkValue (m, currMod, NULL, t, v); FOR_EACH_LIST_ELMT (v, ase->supplierInvokes) ValueLinkValue (m, currMod, NULL, t, v); } /* ValueLinkRosAseMacroType */ void ValueLinkRosAcMacroType PARAMS ((m, currMod, head, t, bt, ac), ModuleList *m _AND_ Module *currMod _AND_ TypeDef *head _AND_ Type *t _AND_ BasicType *bt _AND_ RosAcMacroType *ac) { Value *v; OID *oid; FOR_EACH_LIST_ELMT (v, ac->nonRoElements) ValueLinkValue (m, currMod, NULL, t, v); ValueLinkType (m, currMod, head, ac->bindMacroType); ValueLinkType (m, currMod, head, ac->unbindMacroType); FOR_EACH_LIST_ELMT (v, ac->operationsOf) ValueLinkValue (m, currMod, NULL, t, v); FOR_EACH_LIST_ELMT (v, ac->initiatorConsumerOf) ValueLinkValue (m, currMod, NULL, t, v); FOR_EACH_LIST_ELMT (v, ac->responderConsumerOf) ValueLinkValue (m, currMod, NULL, t, v); FOR_EACH_LIST_ELMT (oid, ac->abstractSyntaxes) ValueLinkOid (m, currMod, NULL, NULL, oid); } /* ValueLinkRosAcMacroType */ void ValueLinkMtsasExtensionsMacroType PARAMS ((m, currMod, head, t, bt, exts), ModuleList *m _AND_ Module *currMod _AND_ TypeDef *head _AND_ Type *t _AND_ BasicType *bt _AND_ MtsasExtensionsMacroType *exts) { Value *v; FOR_EACH_LIST_ELMT (v, exts->extensions) ValueLinkValue (m, currMod, NULL, t, v); } /* ValueLinkMtsasExtensionsMacroType */ void ValueLinkMtsasExtensionMacroType PARAMS ((m, currMod, head, t, bt, ext), ModuleList *m _AND_ Module *currMod _AND_ TypeDef *head _AND_ Type *t _AND_ BasicType *bt _AND_ MtsasExtensionMacroType *ext) { ValueLinkElmtType (m, currMod, head, ext->elmtType); ValueLinkValue (m, currMod, NULL, t, ext->defaultValue); } /* ValueLinkMtsasExtensionMacroType */ void ValueLinkMtsasExtensionAttributeMacroType PARAMS ((m, currMod, head, t,bt, ext), ModuleList *m _AND_ Module *currMod _AND_ TypeDef *head _AND_ Type *t _AND_ BasicType *bt _AND_ MtsasExtensionAttributeMacroType *ext) { if (ext != NULL) ValueLinkType (m, currMod, head, ext->type); } /* ValueLinkMtsasExtensionAttributeMacroType */ void ValueLinkMtsasTokenMacroType PARAMS ((m, currMod, head, t, bt, tok), ModuleList *m _AND_ Module *currMod _AND_ TypeDef *head _AND_ Type *t _AND_ BasicType *bt _AND_ MtsasTokenMacroType *tok) { if (tok != NULL) ValueLinkType (m, currMod, head, tok->type); } /* ValueLinkMtsasTokenMacroType */ void ValueLinkMtsasTokenDataMacroType PARAMS ((m, currMod, head, t, bt, tok), ModuleList *m _AND_ Module *currMod _AND_ TypeDef *head _AND_ Type *t _AND_ BasicType *bt _AND_ MtsasTokenDataMacroType *tok) { if (tok != NULL) ValueLinkType (m, currMod, head, tok->type); } /* ValueLinkMtsasTokenDataMacroType */ void ValueLinkMtsasSecurityCategoryMacroType PARAMS ((m, currMod, head, t, bt, sec), ModuleList *m _AND_ Module *currMod _AND_ TypeDef *head _AND_ Type *t _AND_ BasicType *bt _AND_ MtsasSecurityCategoryMacroType *sec) { if (sec != NULL) ValueLinkType (m, currMod, head, sec->type); } /* ValueLinkMtsasSecurityCategoryMacroType */ void ValueLinkAsnObjectMacroType PARAMS ((m, currMod, head, t, bt, obj), ModuleList *m _AND_ Module *currMod _AND_ TypeDef *head _AND_ Type *t _AND_ BasicType *bt _AND_ AsnObjectMacroType *obj) { AsnPort *ap; FOR_EACH_LIST_ELMT (ap, obj->ports) ValueLinkValue (m, currMod, NULL, t, ap->portValue); } /* ValueLinkAsnObjectMacroType */ void ValueLinkAsnPortMacroType PARAMS ((m, currMod, head, t, bt, p), ModuleList *m _AND_ Module *currMod _AND_ TypeDef *head _AND_ Type *t _AND_ BasicType *bt _AND_ AsnPortMacroType *p) { TypeOrValue *tOrV; FOR_EACH_LIST_ELMT (tOrV, p->abstractOps) { if (tOrV->choiceId == TYPEORVALUE_TYPE) ValueLinkType (m, currMod, head, tOrV->a.type); else ValueLinkValue (m, currMod, NULL, t, tOrV->a.value); } FOR_EACH_LIST_ELMT (tOrV, p->supplierInvokes) { if (tOrV->choiceId == TYPEORVALUE_TYPE) ValueLinkType (m, currMod, head, tOrV->a.type); else ValueLinkValue (m, currMod, NULL, t, tOrV->a.value); } FOR_EACH_LIST_ELMT (tOrV, p->consumerInvokes) { if (tOrV->choiceId == TYPEORVALUE_TYPE) ValueLinkType (m, currMod, head, tOrV->a.type); else ValueLinkValue (m, currMod, NULL, t, tOrV->a.value); } } /* ValueLinkAsnPortMacroType */ void ValueLinkAsnAbstractBindMacroType PARAMS ((m, currMod, head, t, bt, bind), ModuleList *m _AND_ Module *currMod _AND_ TypeDef *head _AND_ Type *t _AND_ BasicType *bt _AND_ AsnAbstractBindMacroType *bind) { AsnPort *ap; FOR_EACH_LIST_ELMT (ap, bind->ports) ValueLinkValue (m, currMod, NULL, t, ap->portValue); } /* ValueLinkAsnBindMacroType */ void ValueLinkSnmpObjectTypeMacroType PARAMS ((m, currMod, head, t, bt, ot), ModuleList *m _AND_ Module *currMod _AND_ TypeDef *head _AND_ Type *t _AND_ BasicType *bt _AND_ SnmpObjectTypeMacroType *ot) { TypeOrValue *tOrV; ValueLinkType (m, currMod, head, ot->syntax); ValueLinkValue (m, currMod, NULL, t, ot->description); ValueLinkValue (m, currMod, NULL, t, ot->reference); ValueLinkValue (m, currMod, NULL, t, ot->defVal); FOR_EACH_LIST_ELMT (tOrV, ot->index) { if (tOrV->choiceId == TYPEORVALUE_TYPE) ValueLinkType (m, currMod, head, tOrV->a.type); else ValueLinkValue (m, currMod, NULL, t, tOrV->a.value); } } /* ValueLinkSnmpObjectTypeMacroType */