#include <stdio.h>
#include "asn-incl.h"
#include "mem.h"
#include "asn1module.h"
#include "lib-types.h"
#include "define.h"
#include "snacc-util.h"
void
SetupType PARAMS ((t, typeId, lineNum),
Type **t _AND_
enum BasicTypeChoiceId typeId _AND_
unsigned long lineNum)
{
Tag **tmpPtr;
(*t) = (Type*)Malloc (sizeof (Type));
(*t)->lineNo = lineNum;
(*t)->basicType = (BasicType*)Malloc (sizeof (BasicType));
(*t)->basicType->choiceId = typeId;
(*t)->tags = (TagList*)AsnListNew (sizeof (void*));
if (LIBTYPE_GET_UNIV_TAG_CODE ((typeId)) != NO_TAG_CODE)
{
tmpPtr = (Tag**)AsnListAppend ((AsnList*)(*t)->tags);
*tmpPtr = (Tag*)Malloc (sizeof (Tag));
(*tmpPtr)->tclass = UNIV;
(*tmpPtr)->code = LIBTYPE_GET_UNIV_TAG_CODE ((typeId));
}
}
void
SetupMacroType PARAMS ((t, macroTypeId, lineNum),
Type **t _AND_
enum MacroTypeChoiceId macroTypeId _AND_
unsigned long lineNum)
{
Tag **tmpPtr;
(*t) = MT (Type);
(*t)->lineNo = lineNum;
(*t)->basicType = MT (BasicType);
(*t)->basicType->choiceId = BASICTYPE_MACROTYPE;
(*t)->tags = (TagList*)AsnListNew (sizeof (void*));
(*t)->basicType->a.macroType = MT (MacroType);
(*t)->basicType->a.macroType->choiceId = macroTypeId;
}
void
SetupValue PARAMS ((v, valId, lineNum),
Value **v _AND_
enum BasicValueChoiceId valId _AND_
unsigned long lineNum)
{
*v = (Value*)Malloc (sizeof (Value));
(*v)->basicValue = (BasicValue*)Malloc (sizeof (BasicValue));
(*v)->basicValue->choiceId = valId;
(*v)->lineNo = lineNum;
}
void
AddPrivateImportElmt PARAMS ((m, name, refdModuleName, lineNo),
Module *m _AND_
char *name _AND_
char *refdModuleName _AND_
long int lineNo)
{
ImportElmt *newElmt;
ImportElmt *ie;
ImportModule *impMod;
if ((impMod = LookupImportModule (m, refdModuleName)) == NULL)
{
impMod = MT (ImportModule);
impMod->modId = MT (ModuleId);
impMod->modId->name = Malloc (strlen (refdModuleName)+1);
strcpy (impMod->modId->name, refdModuleName);
newElmt = MT (ImportElmt);
newElmt->name = Malloc (strlen (name)+1);
strcpy (newElmt->name, name);
newElmt->privateScope = TRUE;
APPEND (newElmt, impMod->importElmts);
APPEND (impMod, m->imports);
}
else
{
ie = LookupImportElmtInImportElmtList (impMod->importElmts, name);
if (ie == NULL)
{
newElmt = MT (ImportElmt);
newElmt->name = Malloc (strlen (name)+1);
strcpy (newElmt->name, name);
APPEND (newElmt, impMod->importElmts);
}
else if (!ie->privateScope)
{
PrintErrLoc (m->asn1SrcFileName, lineNo);
fprintf (stderr, "WARNING - \"%s.%s\" type/value reference refers to a type/value already in the import list that does not have private scope.\n", refdModuleName, name);
}
}
}
ImportElmt*
LookupImportElmtInModule PARAMS ((m, name, foundImportModule),
Module *m _AND_
char *name _AND_
ImportModule **foundImportModule)
{
ImportModule *importMod;
ImportElmt *importElmt;
ImportElmt *retVal;
void *tmp;
if (m->imports == NULL)
return NULL;
tmp = (void*)CURR_LIST_NODE (m->imports);
retVal = NULL;
FOR_EACH_LIST_ELMT (importMod, m->imports)
{
importElmt = LookupImportElmtInImportElmtList (importMod->importElmts, name);
if (importElmt != NULL)
{
*foundImportModule = importMod;
retVal = importElmt;
break;
}
}
SET_CURR_LIST_NODE (m->imports, tmp);
return retVal;
}
ImportElmt*
LookupImportElmtInImportElmtList PARAMS ((impElmtList, name),
ImportElmtList *impElmtList _AND_
char *name)
{
ImportElmt *impElmt;
ImportElmt *retVal;
void *tmp;
if (impElmtList == NULL)
return NULL;
tmp = (void*) CURR_LIST_NODE (impElmtList);
retVal = NULL;
FOR_EACH_LIST_ELMT (impElmt, impElmtList)
{
if (strcmp (impElmt->name, name) == 0)
{
retVal = impElmt;
break;
}
}
SET_CURR_LIST_NODE (impElmtList, tmp);
return retVal;
}
ImportModule*
LookupImportModule PARAMS ((m, importModuleName),
Module *m _AND_
char *importModuleName)
{
ImportModule *importModule;
ImportModule *retVal;
void *tmp;
if (m->imports == NULL)
return NULL;
tmp = (void*)CURR_LIST_NODE (m->imports);
retVal = NULL;
FOR_EACH_LIST_ELMT (importModule, m->imports)
{
if (strcmp (importModule->modId->name, importModuleName) == 0)
{
retVal= importModule;
break;
}
}
SET_CURR_LIST_NODE (m->imports, tmp);
return retVal;
}
TypeDef*
LookupType PARAMS ((typeDefList, typeName),
TypeDefList *typeDefList _AND_
char *typeName)
{
TypeDef *td;
TypeDef *retVal;
void *tmp;
if (typeDefList == NULL)
return NULL;
if (typeName == NULL)
{
#ifdef DEBUG
fprintf (stderr,"LookupType: warning - failure due to NULL key\n");
#endif
return NULL;
}
tmp = (void*)CURR_LIST_NODE (typeDefList);
retVal = NULL;
FOR_EACH_LIST_ELMT (td, typeDefList)
{
if (strcmp (typeName, td->definedName) == 0)
{
retVal = td;
break;
}
}
SET_CURR_LIST_NODE (typeDefList,tmp);
return retVal;
}
Module*
LookupModule PARAMS ((moduleList, modName, oid),
ModuleList *moduleList _AND_
char *modName _AND_
OID *oid)
{
Module *currMod;
Module *retVal;
int strMatch = FALSE;
int oidMatch = FALSE;
OID *oid1;
OID *oid2;
void *tmp;
if ((moduleList == NULL) || ((modName == NULL) && (oid == NULL)))
return NULL;
tmp = (void*)CURR_LIST_NODE (moduleList);
retVal = NULL;
FOR_EACH_LIST_ELMT (currMod, moduleList)
{
if (CompareOids (oid, currMod->modId->oid))
{
retVal = currMod;
break;
}
else if ((modName != NULL) &&
(strcmp (modName, currMod->modId->name) == 0))
{
retVal = currMod;
break;
}
}
SET_CURR_LIST_NODE (moduleList, tmp);
return retVal;
}
NamedType*
LookupFieldInType PARAMS ((tRef, fieldName),
Type *tRef _AND_
char *fieldName)
{
NamedType *e;
NamedType *retVal;
Type *t;
void *tmp;
t = ParanoidGetType (tRef);
if ((t->basicType->choiceId != BASICTYPE_SET) &&
(t->basicType->choiceId != BASICTYPE_SEQUENCE) &&
(t->basicType->choiceId != BASICTYPE_CHOICE))
{
#ifdef DEBUG
fprintf (stderr,"LookupFieldInType: ERROR - attempt to look for field in a non SET/SEQ/CHOICE type\n");
#endif
return NULL;
}
if (t->basicType->a.set == NULL)
return NULL;
tmp = (void*)CURR_LIST_NODE (t->basicType->a.set);
retVal = NULL;
FOR_EACH_LIST_ELMT (e, t->basicType->a.set)
{
if ((e->fieldName != NULL) && (strcmp (e->fieldName, fieldName) == 0))
{
retVal = e;
break;
}
}
SET_CURR_LIST_NODE (t->basicType->a.set, tmp);
return retVal;
}
Type*
GetType PARAMS ((type),
Type *type)
{
TypeDef *td;
Type *t;
t = type;
if (t == NULL)
return NULL;
while (1)
{
switch (t->basicType->choiceId)
{
case BASICTYPE_LOCALTYPEREF:
case BASICTYPE_IMPORTTYPEREF:
td = t->basicType->a.localTypeRef->link;
if (td == NULL)
return type;
else
t = td->type;
break;
default:
return t;
}
}
}
Type*
ParanoidGetType PARAMS ((type),
Type *type)
{
TypeDef *td;
Type *t;
DefinedObj *l;
t = type;
if (t == NULL)
return NULL;
l = NewObjList();
while (1)
{
switch (t->basicType->choiceId)
{
case BASICTYPE_LOCALTYPEREF:
case BASICTYPE_IMPORTTYPEREF:
td = t->basicType->a.localTypeRef->link;
if ((td == NULL) || (ObjIsDefined (l, td->type, ObjPtrCmp)))
{
return type;
}
else
{
t = td->type;
DefineObj (&l, t);
}
break;
default:
FreeDefinedObjs (&l);
return t;
}
}
}
enum BasicTypeChoiceId
GetBuiltinType PARAMS ((t),
Type *t)
{
Type *definingType;
definingType = GetType (t);
if (definingType != NULL)
return definingType->basicType->choiceId;
else
return -1;
}
enum BasicTypeChoiceId
ParanoidGetBuiltinType PARAMS ((t),
Type *t)
{
Type *definingType;
definingType = ParanoidGetType (t);
if (definingType != NULL)
return definingType->basicType->choiceId;
else
return -1;
}
NamedNumberList*
GetNamedElmts PARAMS ((t),
Type *t)
{
Type *definingType;
if (t == NULL)
return NULL;
definingType = ParanoidGetType (t);
if (definingType == NULL)
return NULL;
switch (definingType->basicType->choiceId)
{
case BASICTYPE_INTEGER:
case BASICTYPE_ENUMERATED:
case BASICTYPE_BITSTRING:
return definingType->basicType->a.integer;
default:
return NULL;
}
}
NamedNumberList*
GetAllNamedElmts PARAMS ((t),
Type *t)
{
Type *definingType;
NamedType *nt;
NamedNumberList *retVal;
NamedNumberList *ntElmtList;
ValueDef *nn;
ValueDef **nnHndl;
retVal = AsnListNew (sizeof (void*));
if (t == NULL)
return retVal;
definingType = ParanoidGetType (t);
if (definingType == NULL)
return retVal;
switch (definingType->basicType->choiceId)
{
case BASICTYPE_INTEGER:
case BASICTYPE_ENUMERATED:
case BASICTYPE_BITSTRING:
FOR_EACH_LIST_ELMT (nn, definingType->basicType->a.integer)
{
nnHndl = (ValueDef**)AsnListAppend (retVal);
*nnHndl = nn;
}
break;
case BASICTYPE_CHOICE:
FOR_EACH_LIST_ELMT (nt, definingType->basicType->a.choice)
{
ntElmtList = GetAllNamedElmts (nt->type);
retVal = AsnListConcat (retVal, ntElmtList);
Free (ntElmtList);
}
break;
}
return retVal;
}
Type*
GetParent PARAMS ((ancestor, child),
Type *ancestor _AND_
Type *child)
{
NamedType *e;
Type *parent;
void *tmp;
if ((ancestor->basicType->choiceId != BASICTYPE_SET) &&
(ancestor->basicType->choiceId != BASICTYPE_SEQUENCE) &&
(ancestor->basicType->choiceId != BASICTYPE_CHOICE) &&
(ancestor->basicType->choiceId != BASICTYPE_SETOF) &&
(ancestor->basicType->choiceId != BASICTYPE_SEQUENCEOF))
{
return NULL;
}
if (ancestor->basicType->a.set == NULL)
return NULL;
if ((ancestor->basicType->choiceId == BASICTYPE_SETOF) ||
(ancestor->basicType->choiceId == BASICTYPE_SEQUENCEOF))
{
if (child == ancestor->basicType->a.setOf)
return ancestor;
else
return GetParent (ancestor->basicType->a.setOf, child);
}
tmp = (void*)CURR_LIST_NODE (ancestor->basicType->a.set);
FOR_EACH_LIST_ELMT (e, ancestor->basicType->a.set)
{
if (child == e->type)
{
SET_CURR_LIST_NODE (ancestor->basicType->a.set, tmp);
return ancestor;
}
}
FOR_EACH_LIST_ELMT (e, ancestor->basicType->a.set)
{
if ((parent = GetParent (e->type, child)) != NULL)
{
SET_CURR_LIST_NODE (ancestor->basicType->a.set, tmp);
return parent;
}
}
SET_CURR_LIST_NODE (ancestor->basicType->a.set, tmp);
return NULL;
}
ValueDef*
LookupValue PARAMS ((valueList, valueName),
ValueDefList *valueList _AND_
char *valueName)
{
ValueDef *v;
ValueDef *retVal;
void *tmp;
if (valueName == NULL)
{
#ifdef DEBUG
fprintf (stderr,"LookupType: warning - failure due to NULL key\n");
#endif
return NULL;
}
if (valueList == NULL)
return NULL;
tmp = (void*)CURR_LIST_NODE (valueList);
retVal = NULL;
FOR_EACH_LIST_ELMT (v, valueList)
{
if (strcmp (valueName, v->definedName) == 0)
{
retVal = v;
break;
}
}
SET_CURR_LIST_NODE (valueList, tmp);
return retVal;
}
Value*
GetValue PARAMS ((v),
Value *v)
{
ValueDef *vd;
while (v != NULL)
{
switch (v->basicValue->choiceId)
{
case BASICVALUE_LOCALVALUEREF:
case BASICVALUE_IMPORTVALUEREF:
vd = v->basicValue->a.localValueRef->link;
if (vd == NULL)
v = NULL;
else
v = vd->value;
break;
default:
return v;
}
}
fprintf (stderr, "GetValue: ERROR - cannot get value for unlinked local/import value refs\n");
return NULL;
}
int
CompareOids PARAMS ((oid1, oid2),
OID *oid1 _AND_
OID *oid2)
{
if ((oid1 == NULL) && (oid2 == NULL))
return FALSE;
for (; (oid1 != NULL) && (oid2 != NULL); oid1 = oid1->next, oid2 = oid2->next)
{
if ((oid1->arcNum == NULL_OID_ARCNUM) ||
(oid2->arcNum == NULL_OID_ARCNUM) ||
(oid1->arcNum != oid2->arcNum))
return FALSE;
}
if ((oid1 == NULL) && (oid2 == NULL))
return TRUE;
else
return FALSE;
}
int
HasNamedElmts PARAMS ((t),
Type *t)
{
return ((t->basicType->choiceId == BASICTYPE_INTEGER) ||
(t->basicType->choiceId == BASICTYPE_ENUMERATED) ||
(t->basicType->choiceId == BASICTYPE_BITSTRING)) &&
(t->basicType->a.integer != NULL) &&
!LIST_EMPTY (t->basicType->a.integer);
}
int
TagsAreIdentical PARAMS ((t1, t2),
TagList *t1 _AND_
TagList *t2)
{
Tag *tag1;
Tag *tag2;
if (((t1 == NULL) || LIST_EMPTY (t1)) &&
((t2 == NULL) || LIST_EMPTY (t2)))
return TRUE;
else if ((t1 == NULL) || (t2 == NULL))
return FALSE;
else if (LIST_COUNT (t1) == LIST_COUNT (t2))
{
SET_CURR_LIST_NODE (t2, FIRST_LIST_NODE (t2));
FOR_EACH_LIST_ELMT (tag1, t1)
{
tag2 = (Tag*) CURR_LIST_ELMT (t2);
if ((tag1->tclass != tag2->tclass) || (tag1->code == tag2->code))
return FALSE;
SET_CURR_LIST_NODE (t2, NEXT_LIST_NODE (t2));
}
return TRUE;
}
else
return FALSE;
}
int
HasDefaultTag PARAMS ((t),
Type *t)
{
Tag *firstTag = NULL;
int dfltCode;
int dfltClass;
dfltClass = UNIV;
dfltCode = LIBTYPE_GET_UNIV_TAG_CODE (t->basicType->choiceId);
if ((t->tags != NULL) && !LIST_EMPTY (t->tags))
firstTag = (Tag*)FIRST_LIST_ELMT (t->tags);
return ((firstTag != NULL) && (LIST_COUNT (t->tags) == 1) &&
(firstTag->tclass == dfltClass) && (firstTag->code == dfltCode)) ||
((firstTag == NULL) && (dfltCode == NO_TAG_CODE));
}
int
IsPrimitiveByDefOrRef PARAMS ((t),
Type *t)
{
Type *definingType;
definingType = GetType (t);
if (definingType == NULL)
return FALSE;
return IsPrimitiveByDef (definingType);
}
int
IsPrimitiveByDef PARAMS ((t),
Type *t)
{
switch (t->basicType->choiceId)
{
case BASICTYPE_LOCALTYPEREF:
case BASICTYPE_IMPORTTYPEREF:
case BASICTYPE_SEQUENCE:
case BASICTYPE_SET:
case BASICTYPE_CHOICE:
case BASICTYPE_SEQUENCEOF:
case BASICTYPE_SETOF:
case BASICTYPE_COMPONENTSOF:
case BASICTYPE_ANYDEFINEDBY:
case BASICTYPE_ANY:
return FALSE;
break;
case BASICTYPE_SELECTION:
if (t->basicType->a.selection->link != NULL)
return IsPrimitiveByDef (t->basicType->a.selection->link->type);
break;
case BASICTYPE_BOOLEAN:
case BASICTYPE_INTEGER:
case BASICTYPE_BITSTRING:
case BASICTYPE_OCTETSTRING:
case BASICTYPE_NULL:
case BASICTYPE_OID:
case BASICTYPE_REAL:
case BASICTYPE_ENUMERATED:
return TRUE;
break;
case BASICTYPE_UNKNOWN:
case BASICTYPE_MACROTYPE:
case BASICTYPE_MACRODEF:
return FALSE;
break;
default:
fprintf (stderr, "IsPrimitiveByDef: ERROR - unknown type id ?!");
}
return FALSE;
}
int
IsTypeRef PARAMS ((t),
Type *t)
{
if ((t->basicType->choiceId == BASICTYPE_LOCALTYPEREF) ||
(t->basicType->choiceId == BASICTYPE_IMPORTTYPEREF))
return TRUE;
else
return FALSE;
}
int
IsDefinedByLibraryType PARAMS ((t),
Type *t)
{
int retVal;
if (t == NULL)
retVal = FALSE;
else if (IsPrimitiveByDef (t))
retVal = TRUE;
else
switch (t->basicType->choiceId)
{
case BASICTYPE_ANYDEFINEDBY:
case BASICTYPE_ANY:
retVal = TRUE;
break;
default:
retVal = FALSE;
}
return retVal;
}
int
IsNewType PARAMS ((t),
Type *t)
{
if (IsDefinedByLibraryType (t) && HasDefaultTag (t) && ! HasNamedElmts (t))
return FALSE;
else if (IsTypeRef (t) && ((t->tags == NULL) || (LIST_EMPTY (t->tags))))
return FALSE;
else
return TRUE;
}
int
IsTailOptional PARAMS ((e),
NamedTypeList *e)
{
NamedType *elmt;
void *tmp;
int retVal;
if (e == NULL)
return TRUE;
tmp = (void*)CURR_LIST_NODE (e);
if (tmp == NULL)
return TRUE;
retVal = TRUE;
FOR_REST_LIST_ELMT (elmt, e)
{
if ((!elmt->type->optional) && (elmt->type->defaultVal == NULL))
{
retVal = FALSE;
break;
}
}
SET_CURR_LIST_NODE (e, tmp);
return retVal;
}
int
NextIsTailOptional PARAMS ((e),
NamedTypeList *e)
{
NamedType *elmt;
void *tmp;
void *tmp2;
int retVal;
if ((e == NULL) || (LIST_EMPTY (e)))
return TRUE;
tmp = (void*)CURR_LIST_NODE (e);
if (tmp == NULL)
return TRUE;
tmp2 = (void*)NEXT_LIST_NODE (e);
if (tmp2 == NULL)
return TRUE;
SET_CURR_LIST_NODE (e, tmp2);
retVal = TRUE;
FOR_REST_LIST_ELMT (elmt, e)
{
if ((!elmt->type->optional) && (elmt->type->defaultVal == NULL))
{
retVal = FALSE;
break;
}
}
SET_CURR_LIST_NODE (e, tmp);
return retVal;
}
int
AllElmtsOptional PARAMS ((e),
NamedTypeList *e)
{
NamedType *elmt;
void *tmp;
int retVal;
if ((e == NULL) || LIST_EMPTY (e))
return TRUE;
tmp = (void*)CURR_LIST_NODE (e);
SET_CURR_LIST_NODE (e, FIRST_LIST_NODE (e));
retVal = TRUE;
FOR_REST_LIST_ELMT (elmt, e)
{
if ((!elmt->type->optional) && (elmt->type->defaultVal == NULL))
{
retVal = FALSE;
break;
}
}
SET_CURR_LIST_NODE (e, tmp);
return retVal;
}
AnyRefList**
GetAnyRefListHndl PARAMS ((t),
Type *t)
{
TypeDef *td;
if (IsDefinedByLibraryType (t))
return LIBTYPE_GET_ANY_REFS_HNDL (t->basicType->choiceId);
else
{
if (!IsTypeRef (t))
return NULL;
else
{
td = t->basicType->a.localTypeRef->link;
return &td->anyRefs;
}
}
}
void
AppendSubtype PARAMS ((s, newSubtype, op),
Subtype **s _AND_
Subtype *newSubtype _AND_
enum SubtypeChoiceId op)
{
void **tmpPtr;
Subtype *sPtr;
if (*s == NULL)
*s = newSubtype;
else if (op == SUBTYPE_AND)
{
if ((*s)->choiceId == SUBTYPE_AND)
{
tmpPtr = (void**)AsnListAppend ((*s)->a.and);
*tmpPtr = (void*)newSubtype;
}
else
{
sPtr = (Subtype*)Malloc (sizeof (Subtype));
sPtr->choiceId = SUBTYPE_AND;
sPtr->a.and = NEWLIST();
tmpPtr = (void**)AsnListAppend (sPtr->a.and);
*tmpPtr = (void*)*s;
tmpPtr = (void**)AsnListAppend (sPtr->a.and);
*tmpPtr = (void*)newSubtype;
*s = sPtr;
}
}
else if (op == SUBTYPE_OR)
{
if ((*s)->choiceId == SUBTYPE_OR)
{
tmpPtr = (void**)AsnListAppend ((*s)->a.or);
*tmpPtr = (void*)newSubtype;
}
else
{
sPtr = (Subtype*)Malloc (sizeof (Subtype));
sPtr->choiceId = SUBTYPE_OR;
sPtr->a.or = NEWLIST();
tmpPtr = (void**)AsnListAppend (sPtr->a.or);
*tmpPtr = (void*)*s;
tmpPtr = (void**)AsnListAppend (sPtr->a.or);
*tmpPtr = (void*)newSubtype;
*s = sPtr;
}
}
else
fprintf (stderr,"AppendSubtype - unknown operation\n");
}